Saravanan666/pypi-org huggingface dataset:
Package: observe-http-sender
Python Class for Sending Data to ObserveInc HTTP EndpointVersion/Date: 1.3.2 2023-1-21Description:This is a python class to send events to an Observe Inc Datastream via theHTTP API endpoint.Using this Python ClassUsage: ManualYou will need to put this with any other code and import the class as needed.Instantiate a copy of theObserveHttpSenderobjectSubmit JSON dictionary payload(s) via thepost_observationmethod.Call theflushmethod to ensure any non batched payload data is flushed to Observe.Usage: With pip3pip3 install observe_http_sender@git+ssh://git@github.com/observeinc/observe-http-sender-python.gitOnce installed you can start python try the following.Python Test:from observe_http_sender import ObserveHttpSender 
help(ObserveHttpSender)Getting Started:The arguments needed to initialize an Observer:OBSERVE_URL -- The base Observe customer URL - required (Example:https://154418444508.observeinc.com/)OBSERVE_TOKEN -- The configured Datastream API Token - requiredPython Usage:from observe_http_sender import ObserveHttpSender

# Setup Observer and its logging level.
observer = ObserveHttpSender(OBSERVE_URL,OBSERVE_TOKEN)
observer.log.setLevel(logging.INFO)LoggingYou may use logging by setting up a logger in your code from theimport loggingmodule.logging.basicConfig(format='%(asctime)s %(name)s %(levelname)s %(message)s', datefmt='%Y-%m-%d %H:%M:%S %z')
logger = logging.getLogger(u"OBSERVE_EXAMPLE")
logger.setLevel(logging.INFO)You may set a different logging level for theObserveHttpSenderclass.# Setup Observer and its logging level.
observer = ObserveHttpSender(OBSERVE_CUSTOMER,OBSERVE_TOKEN,OBSERVE_DOMAIN)
observer.log.setLevel(logging.INFO)Notes:Thecheck_connectivitymethod that is optional but recommended before attempting to submit large amounts of data to Observe. See example.py for use and docstrings on the method for details.You MUST call the methodflushbefore your code completes to ensure all remaining non batch posted data is sent to Observe.Methodsget_pop_empty_fieldsandset_pop_empty_fields. Defaults to True to remove empty/null fields from payloads to save ingestion cost.Methodsget_payload_json_formatandset_payload_json_format. Defaults to True to post payload in formatapplication/json. False will post the payload in formattext/plainSet this at instantiation for text payloads.Methodsget_post_pathandset_post_path. Defaults to None append an optional path segment example/orca/alerts. This will show in the Datastream EXTRAS field aspath.Example Usage:The included python scriptexample-postcsv.pytakes a csv file with a header row and posts it to Observe in JSON format.Usage:python3 example-postcsv.py data/sample-authevents.csv
Package: observer-pattern
observer-patternSimple Observer Pattern Implementationfromobserver_patternimportObservablecounter=0defplus_n(n):globalcountercounter+=ndefplus_2n(n):globalcountercounter+=2*ndefplus_3n(n):globalcountercounter+=3*nobservable=Observable()observable.subscribe(plus_n)observable.subscribe(plus_2n)observable.subscribe(plus_3n)observable.notify(2)observable.unsubscribe(plus_3n)observable.notify(5)print(counter)# 27print(len(observable))# 2You can pass any number ofargsandkwargsdefprint_product(a,b):print(a*b)observable=Observable()observable.subscribe(print_product)observable.notify(3,b=5)# 15print(print_productinobservable)# True
Package: observer.simple
A simple implementation of the observer pattern.importobserver# Create a subject and list the events it might firefoo=observer.Subject('bar','baz')# Add a listenerdeffoo_bar_listener(*args):print("heard 'bar'",args)foo('bar',foo_bar_listener)# fire eventsfoo.fire('bar',1,2,3)# -> heard 'bar' (1, 2, 3)# Trying to listen to an unregistered event throws an errorfoo('snorble',lambda:None)# -> AssertionError: snorble is not a valid event for this subject# Same with trying to fire an unregistered eventfoo.fire('snorble')# -> AssertionError: snorble is not a valid event for this subject
Package: obserware
ObserwareAn advanced system monitor utility written in Python and QtAboutObserware makes monitoring of advanced metrics accessible with the use of interactive graphs and charts. It is built on free and open-source technologies such as Python, Psutil, PyCPUinfo, Distro and Qt5. With the use of the utility, you can monitorAdvanced overview of the system health by monitoring CPU usage, memory utilization and swapping rateGranular counts of context switches, system calls and interrupts of both natures, software and hardwarePer-core/per-thread CPU utilization, measured in both stress percentage and active clock speedsPer-core/per-thread CPU state times, measured in both occupancy percentage and duration in secondsUsage/availability information, measured in both occupancy percentage and active size in megabytesStorage counters, measured in unit counts, size in bytes, duration in seconds, merge counts and busy time in secondsGlobal network statistics gathered from all network interface cards, measured in packet count rate and size rateStatistics of uploads and downloads made since boot, measured in packet counts and size in bytesPer-NIC activity, transfer rate in packet counts and bytes, total transmission, dropped transfers and morePer-unit metrics in both, occupancy percentage and active size of physical and logical partitionsStatic information about mount location, file system, unit name and much more of physical and logical partitionsDynamic listing of processes in process IDs, names, terminal, usernames, states, CPU and memory usage and thread countsPer-process information with process IDs, CPU and memory usage, CPU/thread counts, context switches and morePer-process control with options to kill, resume, terminate or suspend those on demandStatic software information on operating system and kernel as well as dependency versions for the applicationStatic hardware information on CPU name, vendor, frequency, available feature flags and moreWhile adapting to the global system-wide theming options on Qt-based desktop environments like KDE Plasma or LXQtFind it onPyPIFedora COPRProduct HuntVoteReviewInstallationFor developmentUsing Poetrysudo dnf install python3-poetrygit clone https://gitlab.com/t0xic0der/obserware.gitcd obserwarevirtualenv venvsource venv/bin/activatepoetry installdeactivateFor consumptionFrom Fedora COPRsudo dnf install dnf-plugins-core -ysudo dnf copr enable t0xic0der/obserware -ysudo dnf install obserware -yFrom PyPIvirtualenv venvsource venv/bin/activatepip3 install obserwaredeactivateUsageFor developmentIf installed via Poetrysource venv/bin/activateobserwaredeactivateFor consumptionIf installed from Fedora COPREither, runobserwarein a terminalOr, invoke the created desktop entryIf installed from PyPIsource venv/bin/activateobserwaredeactivateScreenshotsWindowsResources tabscreenFindhereActivities tabscreenFindherePerformance tabscreenFindhereConnections tabscreenFindherePartitions tabscreenFindhereInformation tabscreenFindhereContribute tabscreenFindhereDialogsProcess information dialogFindhereLoggingSample log outputsFindhere
Package: obsession
Fast WSGI sessions. Zero dependencies. Python 3 ready.Basic usage:import obsession

application = obsession.SessionMiddleware(application)Advanced usage:# Customize all the options
application = obsession.SessionMiddleware(
    application,
    id_persister=obsession.CookieIdPersistence(cookie_name='mysession',
                                               max_age=86400,
                                               path='/my-site',
                                               domain='mysite.example.org'
                                               secure=True),
    backend=obsession.FileBackend(directory='/tmp/session-store',
                                  prefix='session_')
)Your application will now have a session object available inenviron['ob.session'].The session object acts like a regular dictionary:session = environ['ob.session']
session['foo'] = 'bar'
session['bar'] = [1, 2, 3]The session will be saved automatically whenever you mutate the
session object itself - for example by assigning a new key, or reassigning an
existing key. However if you change an already stored value then
you should callsession.save()to ensure your changes are saved.There are some useful extra properties and methods:# Persist the session to the backend
session.save()

# What's my session id?
my_session_id = session.id

# Cycle the session id.
# This generates a new session id and invalidates the old one.
session.cycle()

# Load a session with a known id.
# Useful if you need to pass the session through another service that
# does not have access to the cookie.
s = environ['ob.session']
s.load_id('my_session_id')

# Delete the session.
# This removes all data from the backend storage and deletes the client's
# session cookie
session.delete()
Package: obsidianhtml
An application to export Obsidian notes to standard markdown and an html based website.See the github repository for the code, to raise issues, and further information:https://github.com/obsidian-html/obsidian-htmlYou can see the capabilities of this system on the documentation website:https://obsidian-html.github.io/, which is created from an Obsidian vault using only this package.What it does:The Obsidian notes will be converted to standard markdown output. Then, optionally, html output is created based on the standard markdown.
It is also possible to input existing standard markdown to just use the markdown to html functionality.See the docs for more information on configuring the behavior of ObsidianHtml.Changelog:https://obsidian-html.github.io/Change%20Log.html
Package: obsidianhtml-md-mermaid-fork
md_mermaidThis is a fork that we had to make to publish ObsidianHTML without the bug in the original md_mermaid package. The rest of this readme comes from there.mermaid extension for Python-Markdown to add support for mermaid graph inside markdown fileInstallationForpipinstallation (only python version >=3.x) :pipinstallmarkdown
pipinstallmd-mermaidUsageIn your python script :importmarkdowntext="""# TitleSome text.​~~~mermaidgraph TBA --> BB --> C​~~~Some other text.​~~~mermaidgraph TBD --> EE --> F​~~~"""html=markdown.markdown(text,extensions=['md_mermaid'])print(html)Output will result in :<h1>Title</h1><p>Some text.</p><divclass="mermaid">graph TB
A --> B
B --> C</div><p>Some other text.</p><divclass="mermaid">graph TB
D --> E
E --> F</div><script>mermaid.initialize({startOnLoad:true});</script>The<script>...</script>line appears only once even if there are several graphs in the file.Note that the extension name have a '_' not a '-'.Attention : don't forget to include in your output html project the two following mermaid files :mermaid.css (optional, can be customised)mermaid.min.js (can be download herehere)
Package: obsidian-lab
Obsidian lab python serverSay you have a terrific script in python to:Find similar notes to the current one.Translate a text.Know what was your mood the last three months, just reading your Obsidian vault.Whatever wonder you have under the sleeve :DAnd you want to see if it's helpful in Obsidian.Then you can:Expose your script with this appTry it out with theobsidian labplugin.To installpipinstallobsidian-labUsage:obsidian-lab<scriptsdirectory>This will run a mini web server that exposes the scripts of the directory specified.There are some examples in the ./examples directory, to run do:obsidian-lab./examplesAfter starting, you can list all the available scripts:GET:http://127.0.0.1:5000/{"scripts":["http://127.0.0.1:5000/scripts/hello_world","http://127.0.0.1:5000/scripts/random","http://127.0.0.1:5000/scripts/to_upper_case"]}To add new scripts, copy them in the scripts directory.BuildInstall the dependenciespipinstall-rrequirements.txttry the apppython./src/obsidian_lab/app.py./examplesStatusThis is a proof of concept.
Package: obsidian-parser
Obsidian ParserA small library for a Obsidian Vaults to parse its content. One example is to prepare the content to publishing with static site generators, Hugo as an example.Installationpipinstallobsidian-parserGet startedHow to multiply one number by another with this lib:# Import Multiplication from your libraryfromobsidian_parserimportMultiplication# Instantiate a Multiplication objectmultiplication=Multiplication(2)# Call the multiply methodprint(multiplication.multiply(5))
Package: obsidian-progress-report
obsidian-progress-reportA simple command line app for generating progress report for contributions in the Obsidian vaultInstallationUsing Pip$pipinstallobsidian-progress-reportManual$gitclonehttps://github.com/aviskase/obsidian-progress-report
$cdobsidian-progress-report
$pythonsetup.pyinstallUsageRun with defaults (generate report of all created and updated files for the current month and save in vault's root):$obsidian-progress-report<vault>wherevaultis a path to the Obsidian's vault directory.You can also change defaults:-o <name>save to subdirectory of vault, for example:-o Reports-s 2020-01-04and-e 2020-09-05to change reporting period-i createdor-i updatedto include only specific sections-c createdAtfor specifying custom frontmatter field on LinuxLinuxSince there is no robust way to get file creation date on Linux, you must use YAML frontmatter in your markdown files.By default the script is searching forcreatedfield, but you can change it with-coption. Example:---
created: 2020-08-31T00:05:23
# or created: 2020-08-31

---

# Some noteReport structure# 2020-08-31 – 2020-08-31

## Created

- [[Test note]]


## Updated

- [[Second note]]
- [[Third note]]BuildingTest locally:python setup.py installCreate build:python setup.py sdist bdist_wheelUpload build:twine upload dist/*
Package: obsidianpy
Adiscord.pyready wrapper for the audio sending node,ObsidianInstallTo install the library, you need the lastest version of pip and minimum Python 3.8Stable versionpip install obsidianpyUnstable version (this one gets more frequent changes)pip install git+https://github.com/cloudwithax/obsidian.pySupportYou can join our support serverhereExamplesIn-depth examples are located in the examples folderHere's a quick example:importobsidianimportdiscordimportrefromdiscord.extimportcommandsURL_REG=re.compile(r'https?://(?:www\.)?.+')classMyBot(commands.Bot):def__init__(self)->None:super().__init__(command_prefix='!',activity=discord.Activity(type=discord.ActivityType.listening,name='to music!'))self.add_cog(Music(self))asyncdefon_ready(self)->None:print("I'm online!")awaitself.cogs["Music"].start_nodes()classMusic(commands.Cog):def__init__(self,bot)->None:self.bot=botself.obsidian=obsidian.NodePool()asyncdefstart_nodes(self):awaitself.obsidian.create_node(bot=self.bot,host='127.0.0.1',port='3030',password='youshallnotpass',identifier='MAIN')print(f"Node is ready!")@commands.command(name='join',aliases=['connect'])asyncdefjoin(self,ctx:commands.Context,*,channel:discord.TextChannel=None)->None:ifnotchannel:channel=getattr(ctx.author.voice,'channel',None)ifnotchannel:raisecommands.CheckFailure('You must be in a voice channel to use this command''without specifying the channel argument.')awaitctx.author.voice.channel.connect(cls=obsidian.Player)awaitctx.send(f'Joined the voice channel `{channel}`')@commands.command(name='play')asyncdefplay(self,ctx,*,search:str)->None:ifnotctx.voice_client:awaitctx.invoke(self.join)player=ctx.voice_clientresults=awaitplayer.get_tracks(query=f'ytsearch:{search}')ifnotresults:raisecommands.CommandError('No results were found for that search term.')ifisinstance(results,obsidian.Playlist):awaitplayer.play(track=results.tracks[0])else:awaitplayer.play(track=results[0])bot=MyBot()bot.run("token here")FAQWhy is it saying "Cannot connect to host"?You need to have an Obsidian node setup before you can use this library. Download it directlyhereWhat experience do I need?This library requires that you have some experience with Python, asynchronous programming and the discord.py library.Why is it saying "No module named obsidian found"?You need toinstallthe package before you can use it
Package: obsidian.py
obsidian.pyA wrapper around Obsidian's REST and Websocket API.View on PyPIorRead the DocsWhat is obsidian.py?A fully object-oriented wrapper aroundObsidian v2designed fordiscord.py.This wrapper is based off ofSlate.RequirementsPython (3.7+)discord.pyaiohttpObsidian (v2)Java JDK 16Obsidian v2obsidian.ymlFeatures100% coverageFully asynchronousObject orientedPlaylist supportAdvanced audio filter supportQuerying tracks from many sourcesSpotify supportPreset classesFully typedDocumentationYou can view documentation on the core libraryhere.Setting up Obsidian & obsidian.pyDownloading ObsidianFirst, we must download Obsidian itself.The JAR located in current Obsidian respoitory is outdated, however the working build can be downloadedhere.Creating obsidian.ymlYou must have anobsidian.ymlfile before running Obsidian.Create/download the file in the same directory as the JAR file (mentioned above).Installing obsidian.pyNext, let's install obsidian.py.You can download it directly from PyPI (Usingpip):$pipinstallobsidian.pyOr, if you want early access to new additions for obsidian.py, clone directly from Github:$pipinstallgit+https://github.com/jay3332/obsidian.pyRunning ObsidianMake sure you haveJava 16or higher downloaded.To run Obsidian,cdto the directory the JAR file you downloaded above is located in:$cd/path/to/directoryThen, run it using Java's command line tool:$cd/path/to/directory

$java-jarObsidian.jar(ReplaceObsidian.jarto the name of the JAR file.)If successful, you should see many things getting logged into console.You're all set - now you just have to write code.See below for examples, or take a look into theexamples folder.ExamplesBasicimportdiscordimportobsidianfromdiscord.extimportcommandsclassBot(commands.Bot):def__init__(self,**options):super().__init__(**options)self.loop.create_task(self.start_obsidian)asyncdefstart_obsidian(self):self.obsidian=awaitobsidian.initiate_node(bot=self)bot=Bot(command_prefix='$')@bot.command()asyncdefconnect(ctx):channel=ctx.author.voice.channelplayer=ctx.bot.obsidian.get_player(ctx.guild)awaitplayer.connect(channel)@bot.command()asyncdefplay(ctx,*,song:str):player=ctx.bot.obsidian.get_player(ctx.guild)track=awaitctx.bot.obsidian.search_track(song,source=obsidian.Source.YOUTUBE)awaitplayer.play(track)if__name__=='__main__':bot.run('TOKEN')CreditsHeavily based off ofSlateInspired bywavelinkChangelogThe changelog has been moved to ourdocumentation page.
Package: obsidian-to-latex
Obsidian to LatexThis utility attempts to make it easy to convert markdown documents written using obsidian into PDFs.RequirementslatexmermaidGetting StartedThis project uses pythonpoetry.  Follow theintallation instructionsfor poetry.I'm using miktex for latex support.  On windows, you can runwinget install miktexRunpoetry installandpoetry shellto install and and activate the python virtual environment.Than, runobsidian_to_latex .\examples\feature_guide\Widget.mdto convert the example document to a PDF.  The PDF will be placed in.\examples\feature_guide\output\Widget.pdf.watchexec.exe-crd500-epy"isort . && black . && pytest && obsidian_to_latex.cmd .\examples\feature_guide\Widget.md"
Package: obsidian-to-typst
Obsidian to TypstThis utility attempts to make it easy to convert markdown documents written using obsidian into PDFs.RequirementstypstmermaidmutoolGetting StartedThis project uses pythonpoetry.  Follow theintallation instructionsfor poetry.Install typst using a package manager orcargo installRunpoetry installandpoetry shellto install and and activate the python virtual environment.Than, runobsidian_to_typst .\examples\feature_guide\Widget.mdto convert the example document to a PDF.  The PDF will be placed in.\examples\feature_guide\output\Widget.pdf.watchexec.exe-crd500-epy"isort . && black . && pytest && obsidian_to_typst.cmd .\examples\feature_guide\Widget.md"
Package: obsidian-traverse
obsidian-traverseRecursively list all files linked by Obsidian note.Installationpipinstallobsidian-traverseUsageusage: obsidian-traverse [-h] -d DIRECTORY [--abspath] NOTES [NOTES ...]

Recursively list all files linked by Obsidian note.

positional arguments:
  NOTES                 Notes to traverse

options:
  -h, --help            show this help message and exit
  -d DIRECTORY, --directory DIRECTORY
                        Vault directory
  --abspath             Output absolute paths of linked filesFixes for emergent parsing problems are welcome!
Package: obs-img-utils
obs-img-utilsoverviewobs-img-utils provides a command line utility and API for images
in Open Build Service.It provides the following commands:Downloading images based on conditionsGet list of packages in an imageGet version info for a specific packageInstallationTo install the package use the following commands as root:$zypperarhttp://download.opensuse.org/repositories/Cloud:/Tools/<distribution>
$zypperrefresh
$zypperinpython3-obs-img-utilsRequirementslxmlClickPyYamlDocsCLI OverviewThe CLI provides multiple subcommands to initiate image testing:obs-img-utils downloadDownload the image with optional condition checking for version
and packages.obs-img-utils packages listShow a list of packages in the given image.obs-img-utils packages showShow version information for provided package.Issues/EnhancementsPlease submit issues and requests toGithub.ContributingContributions to obs-img-utils are welcome and encouraged. SeeCONTRIBUTINGfor info on getting started.LicenseCopyright (c) 2019 SUSE LLC. All rights reserved.Distributed under the terms of GPL-3.0+ license, seeLICENSEfor details.
Package: obsinfo
obsinfois a system for for creating FDSN-standard data and metadata for
ocean bottom seismometers using standardized, easy-to-read information filesCurrent goalTo come out with a first version (v1.x) schema for the information files.  We
would like input from seismologists and ocean bottom seismometer
manufacturers/operators about what information/capabilities are missing.
Existing questions can be found/modified in the gitlabISSUESDocumentationSource codeVersioningWe use standard MAJOR.MINOR.MAINTENANCE version numbering but, while the
system is in prerelease:MAJOR==0MINOR increments every time the information
file structure changes in anon-backwards-compatiblewayMAINTENANCE increments when the code changes or the file structure changes
in abackwards-compatibleway
Package: obsln
ObsLnIntroductionObsPy is a wonderful toolset for seismologists. However, it can be bulky and it has several large dependencies which have to be installed for it to work, even for simple tasks like reading and writing files. ObsLn provides a very limited range of functionality from ObsPy without many of the dependencies and size. In particular this supports:Data stream and trace stucturesReading/Writing  SEGY filesReading SEG2As you will see the much of the code has been shamelessly hacked from ObsPy and the documentation has been left deliberately unaltered. Accordingly it is released under the same license as ObsPy.For full ObsPy functionality please see the ObsPy project on GitHubhereInstallationpip install obslnBuilding the Docker Imagedocker build -t obsln:latest .Running Examples in Docker Imagedocker run -v `pwd`:/src/obsln --entrypoint=/bin/bash obsln:latest -c "python3 /src/obsln/runtest.py"