# packages

pkgId: 00aa948033b403d9d4893f708337640b7087d0f1cf497382ea278f20909ca5fc
name: python-cs.result
arch: src
version: 20240630
epoch: 0
release: 1
summary: Result and friends: various subclassable classes for deferred delivery of values.
url: https://pypi.org/project/cs.result/
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cs.result-20240630-1.src.rpm
checksum_type: sha256
description:
  Result and friends: various subclassable classes for deferred delivery of values.

  *Latest release 20240630*:
  * Move CancellationError from cs.result to cs.fsm.
  * report: avoid iterating over the live set.
  * Result: drop the PREPARE state, allow 'cancel' no-op event in CANCELLED and DONE states.
  * Result.result,exc_info getters: raise CancellationError if the Result is cancelled.
  * Result._complete: fire the 'complete' event after the ._result and ._exc_info attributes are set but still before the self._get_lock.release().
  * Result: preserve message passed to .cancel(), _complete raises RuntimeError if already complete.

  A `Result` is the base class for several callable subclasses
  which will receive values at a later point in time,
  and can also be used standalone without subclassing.

  A call to a `Result` will block until the value is received or the `Result` is cancelled,
  which will raise an exception in the caller.
  A `Result` may be called by multiple users, before or after the value has been delivered;
  if the value has been delivered the caller returns with it immediately.
  A `Result`'s state may be inspected (pending, running, ready, cancelled).
  Callbacks can be registered via a `Result`'s .notify method.

  An incomplete `Result` can be told to call a function to compute its value;
  the function return will be stored as the value unless the function raises an exception,
  in which case the exception information is recorded instead.
  If an exception occurred, it will be reraised for any caller of the `Result`.

  Trite example:

      R = Result(name="my demo")

  Thread 1:

      
      value = R()
      print(value)
      

  Thread 2:

      R.result = 3

  Thread 3:

      value = R()
      

  You can also collect multiple `Result`s in completion order using the `report()` function:

      Rs = [ ... list of Results of whatever type ... ]
      ...
      for R in report(Rs):
          x = R()     # collect result, will return immediately because
                      
          print(x)    # print result



  After the completion of `Rs` call `func(*a,**kw)` and return
  its result via `R`; return the `Result` object.

  Parameters:
  * `Rs`: an iterable of Results.
  * `R`: a `Result` to collect to result of calling `func`.
    If `None`, one will be created.
  * `func`, `a`, `kw`: a callable and its arguments.



  Dispatch a `Thread` to run `func`, return a `Result` to collect its value.

  Parameters:
  * `_name`: optional name for the `Result`, passed to the initialiser
  * `_extra`: optional extra data for the `Result`, passed to the initialiser

  Other parameters are passed to `func`.



  Run `func(*a,**kw)` in a separate `Thread` via the `@in_thread` decorator.
  Return or exception is as for the original function.



  Decorator to evaluate `func` in a separate `Thread`.
  Return or exception is as for the original function.

  This exists to step out of the current `Thread's` thread
  local context, such as a database transaction associated
  with Django's implicit per-`Thread` database context.



  Wrap a callable, run it when required.



  Wrap a callable, run it when required.



  Generator which yields completed `Result`s.

  This is a generator that yields `Result`s as they complete,
  useful for waiting for a sequence of `Result`s
  that may complete in an arbitrary order.



  Base class for asynchronous collection of a result.
  This is used to make `Result`, `OnDemandFunction`s, `LateFunction`s
  and other objects with asynchronous termination.

  In addition to the methods below, for each state value such
  as `self.PENDING` there is a corresponding attribute `is_pending`
  testing whether the `Result` is in that state.

  *Method `Result.__init__(self, name=None, *, lock=None, result=None, state=None, extra=None)`*:
  Base initialiser for `Result` objects and subclasses.

  Parameter:
  * `name`: optional parameter naming this object.
  * `lock`: optional locking object, defaults to a new `threading.Lock`.
  * `result`: if not `None`, prefill the `.result` property.
  * `extra`: an optional mapping of extra information to
    associate with the `Result`, useful to provide context
    when collecting the result; the `Result` has a public
    attribute `.extra` which is an `AttrableMapping` to hold
    this information.

  *Method `Result.__call__(self, *a, **kw)`*:
  Call the `Result`: wait for it to be ready and then return or raise.

  You can optionally supply a callable and arguments,
  in which case `callable(*args,**kwargs)` will be called
  via `Result.call` and the results applied to this `Result`.

  Basic example:

      R = Result()
      ... hand R to something which will fulfil it later ...
      x = R() # wait for fulfilment - value lands in x

  Direct call:

      R = Result()
      ... pass R to something which wants the result ...
      
      
      R(func,1,2,z=3)

  *Method `Result.bg(self, func, *a, **kw)`*:
  Submit a function to compute the result in a separate `Thread`,
  returning the `Thread`.

  Keyword arguments for `cs.threads.bg` may be supplied by
  prefixing their names with an underscore, for example:

      T = R.bg(mainloop, _pre_enter_objects=(S, fs))

  This dispatches a `Thread` to run `self.run_func(func,*a,**kw)`
  and as such the `Result` must be in "pending" state,
  and transitions to "running".

  *Method `Result.cancel(self, msg: Optional[str] = None)`*:
  Cancel this `Result`.

  *Property `Result.cancelled`*:
  Test whether this `Result` has been cancelled.
  Obsolete: use `.is_cancelled`.

  *Method `Result.empty(self)`*:
  Analogue to `Queue.empty()`.

  *Property `Result.exc_info`*:
  The exception information from a completed `Result`.
  This is not available before completion.
  Accessing this on a cancelled `Result` raises `CancellationError`.

  *Method `Result.get(self, default=None)`*:
  Wait for readiness; return the result if `self.exc_info` is `None`,
  otherwise `default`.

  *Method `Result.join(self)`*:
  Calling the `.join()` method waits for the function to run to
  completion and returns a tuple of `(result,exc_info)`.

  On completion the sequence `(result,None)` is returned.
  If an exception occurred computing the result the sequence
  `(None,exc_info)` is returned
  where `exc_info` is a tuple of `(exc_type,exc_value,exc_traceback)`.
  If the function was cancelled the sequence `(None,None)`
  is returned.

  *Method `Result.notify(self, notifier: Callable[[ForwardRef('Result')], NoneType])`*:
  After the `Result` completes, call `notifier(self)`.

  If the `Result` has already completed this will happen immediately.
  If you'd rather `self` got put on some queue `Q`, supply `Q.put`.

  *Property `Result.pending`*:
  Whether the `Result` is pending.
  Obsolete: use `.is_pending`.

  *Method `Result.post_notify(self, post_func) -> 'Result'`*:
  Return a secondary `Result` which processes the result of `self`.

  After the `self` completes, call `post_func(retval)` where
  `retval` is the result of `self`, and use that to complete
  the secondary `Result`.

  *Important note*: because the completion lock object is
  released after the internal `FSM.fsm_event` call, the
  callback used to implement `.post_notify` is fired before
  the lock object is released. As such, it would deadlock as
  it waits for completion of `self` by using that lock.
  Therefore the callback dispatches a separate `Thread` to
  wait for `self` and then run `post_func`.

  Example:

      
      R = submit_packet()
      
      R2 = R.post_notify(lambda response: decode(response))
      
      decoded = R2()

  If the `Result` has already completed this will happen immediately.

  *Method `Result.put(self, value)`*:
  Store the value. `Queue`-like idiom.

  *Method `Result.raise_(self, exc=None)`*:
  Convenience wrapper for `self.exc_info` to store an exception result `exc`.
  If `exc` is omitted or `None`, uses `sys.exc_info()`.

  Examples:

      
      R.raise_()

      
      R.raise_(RuntimeError)

      
      R.raise_(ValueError("bad value!"))

  *Property `Result.ready`*:
  True if the `Result` state is `DONE` or `CANCELLED`..

  *Property `Result.result`*:
  The result.
  This property is not available before completion.
  Accessing this on a cancelled `Result` raises `CancellationError`.

  *Method `Result.run_func(self, func, *a, **kw)`*:
  Fulfil the `Result` by running `func(*a,**kw)`.

  *Method `Result.run_func_in_thread(self, func, *a, **kw)`*:
  Fulfil the `Result` by running `func(*a,**kw)`
  in a separate `Thread`.

  This exists to step out of the current `Thread's` thread
  local context, such as a database transaction associated
  with Django's implicit per-`Thread` database context.

  *Property `Result.state`*:
  The `FSM` state (obsolete).
  Obsolete: use `.fsm_state`.



  A `set` subclass containing `Result`s,
  on which one may iterate as `Result`s complete.

  *Method `ResultSet.__iter__(self)`*:
  Iterating on a `ResultSet` yields `Result`s as they complete.

  *Method `ResultSet.wait(self)`*:
  Convenience function to wait for all the `Result`s.





  *Release 20240630*:
  * Move CancellationError from cs.result to cs.fsm.
  * report: avoid iterating over the live set.
  * Result: drop the PREPARE state, allow 'cancel' no-op event in CANCELLED and DONE states.
  * Result.result,exc_info getters: raise CancellationError if the Result is cancelled.
  * Result._complete: fire the 'complete' event after the ._result and ._exc_info attributes are set but still before the self._get_lock.release().
  * Result: preserve message passed to .cancel(), _complete raises RuntimeError if already complete.

  *Release 20240412*:
  Result.bg: plumb _foo arguments to cs.threads.bg as foo.

  *Release 20240316*:
  Fixed release upload artifacts.

  *Release 20240305*:
  Result.__str__: handle early use where __dict__ lacks various entries.

  *Release 20231221*:
  Doc update.

  *Release 20231129*:
  Result.__del__: issue a warning about no collection instead of raising an exception.

  *Release 20230331*:
  Result.join: access self._result instead of the property.

  *Release 20230212*:
  * Result._complete: release self._get_lock before firing the event, as the event is what fires the notifiers.
  * Result.notify: when we make a direct notifier call, call the notifier outside the lock and remember to set self.collected=True.
  * Result: new post_notify() method to queue a function of the Result.result, returning a Result for the completion of the post function.

  *Release 20221207*:
  CancellationError: accept keyword arguments, apply as attributes.

  *Release 20221118*:
  * CancellationError: rename msg to message.
  * Result.run_func_in_thread: new method to run an arbitrary function in a separate Thread and return it via the Result.
  * New @in_thread decorator to cause a function to run in a separate Thread using Result.run_in_thread.
  * New call_in_thread to run an arbitrary function in a distinct Thread.
  * @in_thread: expose the original function as the decorated function's .direct attribute.

  *Release 20220918*:
  OnDemandResult: modern "pending" check.

  *Release 20220805*:
  Result now subclasses cs.fsm.FSM.

  *Release 20220311*:
  * Result: class local Seq instance.
  * Result.call: thread safe runtime check of self.state==pending.
  * New Task and @task decorator, prototype for rerunnable blocking chaining tasks scheme - very alpha.

  *Release 20210420*:
  Update dependencies, add docstring.

  *Release 20210407*:
  New ResultSet(set) class, with context manager and wait methods, and whose __iter__ iterates completed Results.

  *Release 20210123*:
  bg: accept optional _extra parameter for use by the Result.

  *Release 20201102*:
  Result: now .extra attribute for associated data and a new optional "extra" parameter in the initialiser.

  *Release 20200521*:
  * OnDemandResult: bugfixes and improvements.
  * Result.bg: accept optional _name parameter to specify the Result.name.

  *Release 20191007*:
  * Simplify ResultState definition.
  * Result.bg: use cs.threads.bg to dispatch the Thread.

  *Release 20190522*:
  * Result.__call__ now accepts an optional callable and args.
  * Result.call: set the Result state to "running" before dispatching the function.
  * Rename OnDemandFunction to OnDemandResult, keep old name around for compatibility.
  * Result._complete: also permitted if state==cancelled.

  *Release 20190309*:
  Small bugfix.

  *Release 20181231*:
  * Result.call: report baser exceptions than BaseException.
  * Drop _PendingFunction abstract class.

  *Release 20181109.1*:
  DISTINFO update.

  *Release 20181109*:
  * Derive CancellationError from Exception instead of RuntimeError, fix initialiser.
  * Rename AsynchState to ResultState and make it an Enum.
  * Make Results hashable and comparable for equality for use as mapping keys: equality is identity.
  * New Result.collected attribute, set true if .result or .exc_info are accessed, logs an error if Result.__del__ is called when false, may be set true externally if a Result is not required.
  * Drop `final` parameter; never used and supplanted by Result.notify.
  * Result.join: return the .result and .exc_info properties in order to mark the Result as collected.
  * Result: set .collected to True when a notifier has been called successfully.
  * Bugfix Result.cancel: apply the new cancelled state.

  *Release 20171231*:
  * Bugfix Result.call to catch BaseException instead of Exception.
  * New convenience function bg(func) to dispatch `func` in a separate Thread and return a Result to collect its value.

  *Release 20171030.1*:
  Fix module requirements specification.

  *Release 20171030*:
  New Result.bg(func, *a, **kw) method to dispatch function in separate Thread to compute the Result value.

  *Release 20170903*:
  rename cs.asynchron to cs.result


pkgId: 08b9b0a4f0309477ef8e3715959f6792b1ff6cbba21bb191a339816e886ac5fb
name: python-cs.sqltags
arch: src
version: 20240723
epoch: 0
release: 1
url: https://pypi.org/project/cs.sqltags/
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cs.sqltags-20240723-1.src.rpm
checksum_type: sha256
summary:
  Simple SQL based tagging and the associated `sqltags` command line script, supporting both tagged named objects and tagged timestamped log entries.

description:
  Simple SQL based tagging
  and the associated `sqltags` command line script,
  supporting both tagged named objects and tagged timestamped log entries.

  *Latest release 20240723*:
  * Replace many raises of RuntimeError with NotImplementedError, suggestion by @dimaqq on discuss.python.org.
  * Move some constants from BaseSQLTagsCommand to SQLTagsCommandsMixin where they belong, add missing USAGE_KEYWORDS entry.
  * SQLTagsORM: do not define_schema() in init, instead let the ORM do that and we prepare the metanode on first use of the db - this makes it much cheaper to make an SQLTags and then not use it.

  Compared to `cs.fstags` and its associated `fstags` command,
  this is oriented towards large numbers of items
  not naturally associated with filesystem objects.

  My initial use case is an activity log
  (unnamed timestamped tag sets)
  but I'm also using it for ontologies
  (named tag sets containing metadata).

  Many basic tasks can be performed with the `sqltags` command line utility,
  documented under the `SQLTagsCommand` class below.

  See the `SQLTagsORM` documentation for details about how data
  are stored in the database.
  See the `SQLTagSet` documentation for details of how various
  tag value types are supported.



  Common features for commands oriented around an `SQLTags` database.

  Usage summary:

      Usage: basesqltags [-f db_url] subcommand [...]
        -f db_url SQLAlchemy database URL or filename.
                  Default from $SQLTAGS_DBURL (default '~/var/sqltags.sqlite').
        Subcommands:
          dbshell
            Start an interactive database shell.
          edit criteria...
            Edit the entities specified by criteria.
          export [-F format] [{tag[=value]|-tag}...]
            Export entities matching all the constraints.
            -F format Specify the export format, either CSV or FSTAGS.
          find [-o output_format] {tag[=value]|-tag}...
            List entities matching all the constraints.
            -o output_format
                        Use output_format as a Python format string to lay out
                        the listing.
                        Default: {localtime} {headline}
          help [-l] [subcommand-names...]
            Print help for subcommands.
            This outputs the full help for the named subcommands,
            or the short help for all subcommands if no names are specified.
            -l  Long help even if no subcommand-names provided.
          import [{-u|--update}] {-|srcpath}...
            Import CSV data in the format emitted by "export".
            Each argument is a file path or "-", indicating standard input.
            -u, --update  If a named entity already exists then update its tags.
                          Otherwise this will be seen as a conflict
                          and the import aborted.
          init
            Initialise the database.
            This includes defining the schema and making the root metanode.
          log [-c category,...] [-d when] [-D strptime] {-|headline} [tags...]
            Record entries into the database.
            If headline is '-', read headlines from standard input.
            -c categories
              Specify the categories for this log entry.
              The default is to recognise a leading CAT,CAT,...: prefix.
            -d when
              Use when, an ISO8601 date, as the log entry timestamp.
            -D strptime
              Read the time from the start of the headline
              according to the provided strptime specification.
          orm define_schema
            Runs the ORM's `define_schema()` method, which creates missing tables
            and entity 0 if missing.
          shell
            Run a command prompt via cmd.Cmd using this command's subcommands.
          tag {-|entity-name} {tag[=value]|-tag}...
            Tag an entity with multiple tags.
            With the form "-tag", remove that tag from the direct tags.
            A entity-name named "-" indicates that entity-names should
            be read from the standard input.

  *`BaseSQLTagsCommand.Options`*

  *`BaseSQLTagsCommand.apply_opt(self, opt, val)`*:
  Apply a command line option.

  *`BaseSQLTagsCommand.parse_categories(categories)`*:
  Extract "category" words from the `str` `categories`,
  return a list of category names.

  Splits on commas, strips leading and trailing whitespace, downcases.

  *`BaseSQLTagsCommand.parse_tagset_criterion(arg, tag_based_test_class=None)`*:
  Parse tag criteria from `argv`.

  The criteria may be either:
  * an integer specifying a `Tag` id
  * a sequence of tag criteria

  *`BaseSQLTagsCommand.run_context(self)`*:
  Prepare the `SQLTags` around each command invocation.



  Convert a filename glob to an SQL LIKE pattern.



  Command line mode.



  A `namedtuple` for the polyvalues used in an `SQLTagsORM`.

  We express various types in SQL as one of 3 columns:
  * `float_value`: for `float`s and `int`s which round trip with `float`
  * `string_value`: for `str`
  * `structured_value`: a JSON transcription of any other type

  This allows SQL indexing of basic types.

  Note that because `str` gets stored in `string_value`
  this leaves us free to use "bare string" JSON to serialise
  various nonJSONable types.

  The `SQLTagSets` class has a `to_polyvalue` factory
  which produces a `PolyValue` suitable for the SQL rows.
  NonJSONable types such as `datetime`
  are converted to a `str` but stored in the `structured_value` column.
  This should be overridden by subclasses as necessary.

  On retrieval from the database
  the tag rows are converted to Python values
  by the `SQLTagSets.from_polyvalue` method,
  reversing the process above.



  A mixin for classes with `(float_value,string_value,structured_value)` columns.
  This is used by the `Tags` and `TagMultiValues` relations inside `SQLTagsORM`.



  A mixin for classes with `(float_value,string_value,structured_value)` columns.

  *`PolyValued.as_polyvalue(self)`*:
  Return this row's value as a `PolyValue`.

  *`PolyValued.is_valid(self)`*:
  Test that at most one attribute is non-`None`.

  *`PolyValued.set_polyvalue(self, pv: 'PolyValued')`*:
  Set all the value fields.

  *`PolyValued.value_test(other_value)`*:
  Return `(column,test_value)` for constructing tests against
  `other_value` where `column` if the appropriate SQLAlchemy column
  and `test_value` is the comparison value for testing.

  For most `other_value`s the `test_value`
  will just be `other_value`,
  but for certain types the `test_value` will be:
  * `NoneType`: `None`, and the column will also be `None`
  * `datetime`: `datetime2unixtime(other_value)`



  Convert a prefix string to an SQL LIKE pattern.



  The parameters required for constructing queries
  or extending queries with JOINs.

  Attributes:
  * `criterion`: the source criterion, usually an `SQTCriterion` subinstance
  * `alias`: an alias of the source table for use in queries
  * `entity_id_column`: the `entities` id column,
    `alias.id` if the alias is of `entities`,
    `alias.entity_id` if the alias is of `tags`
  * `constraint`: a filter query based on `alias`



  A `cs.tagset.TagBasedTest` extended with a `.sql_parameters` method.

  *`SQLTagBasedTest.match_tagged_entity(self, te: cs.tagset.TagSet) -> bool`*:
  Match this criterion against `te`.



  A proxy for the tags supporting Python comparison => `SQLParameters`.

  Example:

      sqltags.tags.dotted.name.here == 'foo'



  An object based on a `Tag` name
  which produces an `SQLParameters` when compared with some value.

  Example:

      >>> sqltags = SQLTags('sqlite://')
      >>> sqltags.init()
      >>> # make a SQLParameters for testing the tag 'name.thing'==5
      >>> sqlp = sqltags.tags.name.thing == 5
      >>> str(sqlp.constraint)
      'tags_1.name = :name_1 AND tags_1.float_value = :float_value_1'
      >>> sqlp = sqltags.tags.name.thing == 'foo'
      >>> str(sqlp.constraint)
      'tags_1.name = :name_1 AND tags_1.string_value = :string_value_1'

  *`SQLTagProxy.__eq__(self, other, alias=None) -> cs.sqltags.SQLParameters`*:
  Return an SQL `=` test `SQLParameters`.

  Example:

      >>> sqlp = SQLTags('sqlite://').tags.name.thing == 'foo'
      >>> str(sqlp.constraint)
      'tags_1.name = :name_1 AND tags_1.string_value = :string_value_1'

  *`SQLTagProxy.__ge__(self, other)`*:
  Return an SQL `>=` test `SQLParameters`.

  Example:

      >>> sqlp = SQLTags('sqlite://').tags.name.thing >= 'foo'
      >>> str(sqlp.constraint)
      'tags_1.name = :name_1 AND tags_1.string_value >= :string_value_1'

  *`SQLTagProxy.__getattr__(self, sub_tag_name)`*:
  Magic access to dotted tag names: produce a new `SQLTagProxy` from ourself.

  *`SQLTagProxy.__gt__(self, other)`*:
  Return an SQL `>` test `SQLParameters`.

  Example:

      >>> sqlp = SQLTags('sqlite://').tags.name.thing > 'foo'
      >>> str(sqlp.constraint)
      'tags_1.name = :name_1 AND tags_1.string_value > :string_value_1'

  *`SQLTagProxy.__le__(self, other)`*:
  Return an SQL `<=` test `SQLParameters`.

  Example:

      >>> sqlp = SQLTags('sqlite://').tags.name.thing <= 'foo'
      >>> str(sqlp.constraint)
      'tags_1.name = :name_1 AND tags_1.string_value <= :string_value_1'

  *`SQLTagProxy.__lt__(self, other)`*:
  Return an SQL `<` test `SQLParameters`.

  Example:

      >>> sqlp = SQLTags('sqlite://').tags.name.thing < 'foo'
      >>> str(sqlp.constraint)
      'tags_1.name = :name_1 AND tags_1.string_value < :string_value_1'

  *`SQLTagProxy.__ne__(self, other, alias=None) -> cs.sqltags.SQLParameters`*:
  Return an SQL `<>` test `SQLParameters`.

  Example:

      >>> sqlp = SQLTags('sqlite://').tags.name.thing != 'foo'
      >>> str(sqlp.constraint)
      'tags_1.name = :name_1 AND tags_1.string_value != :string_value_1'

  *`SQLTagProxy.by_op_text(self, op_text, other, alias=None)`*:
  Return an `SQLParameters` based on the comparison's text representation.

  Parameters:
  * `op_text`: the comparsion operation text, one of:
    `'='`, `'<='`, `'<'`, `'>='`, `'>'`, `'~'`.
  * `other`: the other value for the comparison,
    used to infer the SQL column name
    and kept to provide the SQL value parameter
  * `alias`: optional SQLAlchemy table alias

  *`SQLTagProxy.likeglob(self, globptn: str) -> cs.sqltags.SQLParameters`*:
  Return an SQL LIKE test approximating a glob as an `SQLParameters`.

  Example:

      >>> sqlp = SQLTags('sqlite://').tags.name.thing.likeglob('foo*')
      >>> str(sqlp.constraint)
      "tags_1.name = :name_1 AND tags_1.string_value LIKE :string_value_1 ESCAPE '\\'"

  *`SQLTagProxy.startswith(self, prefix: str) -> cs.sqltags.SQLParameters`*:
  Return an SQL LIKE prefix test `SQLParameters`.

  Example:

      >>> sqlp = SQLTags('sqlite://').tags.name.thing.startswith('foo')
      >>> str(sqlp.constraint)
      "tags_1.name = :name_1 AND tags_1.string_value LIKE :string_value_1 ESCAPE '\\'"



  A class using an SQL database to store its `TagSet`s.

  *`SQLTags.TAGSETCLASS_DEFAULT(self, *a, _sqltags=None, **kw)`*:
  Factory to return a suitable `TagSet` subclass instance.
  This produces an `SQLTagSet` instance correctly associated with this `SQLTags`.

  *`SQLTags.TagSetClass(self, *, name, **kw)`*:
  Local implementation of `TagSetClass`
  so that we can annotate it with a `.singleton_also_by` attribute.

  *`SQLTags.__getitem__(self, index)`*:
  Return an `SQLTagSet` for `index` (an `int` or `str`).

  *`SQLTags.__setitem__(self, index, te)`*:
  Dummy `__setitem__` which checks `te` against the db by type
  because the factory has already inserted it into the database.

  *`SQLTags.db_entity(self, index)`*:
  Return the `Entities` instance for `index` or `None`.

  *`SQLTags.db_session(self, *, new=False)`*:
  Context manager to obtain a db session if required
  (or if `new` is true).

  *`SQLTags.default_db_session`*:
  The current per-`Thread` SQLAlchemy Session.

  *`SQLTags.default_factory(self, name: Optional[str] = None, *, unixtime=None, tags=None, skip_refresh=False)`*:
  Fetch or create an `SQLTagSet` for `name`.
  Return the `SQLTagSet`.

  Note that `name` may be `None` to create a new "log" entry.

  *`SQLTags.find(self, *criteria, _without_tags=False, **crit_kw)`*:
  Generate and run a query derived from `criteria`
  yielding `SQLTagSet` instances.

  Parameters:
  * `criteria`: positional arguments which should be
    `SQTCriterion`s or a `str` suitable for `SQTCriterion.from_str`
  * `_without_tags`: optional flag to return entities without tags,
    default `False`;
    this can be used for a much faster scan of the entities
    because it omits the `JOIN` against the tag table
  * `crit_kw`: keyword parameters are appended to the criteria
    as further tag equality tests

  *`SQLTags.flush(self)`*:
  Flush the current session state to the database.

  *`SQLTags.from_str(db_url: str)`*:
  Create an `SQLTags` from `db_url`.

  *`SQLTags.get(self, index, default=None)`*:
  Return an `SQLTagSet` matching `index`, or `None` if there is no such entity.

  *`SQLTags.import_csv_file(self, f, *, update_mode=False)`*:
  Import CSV data from the file `f`.

  If `update_mode` is true
  named records which already exist will update from the data,
  otherwise the conflict will raise a `ValueError`.

  *`SQLTags.import_tagged_entity(self, te, *, update_mode=False) -> None`*:
  Import the `TagSet` `te`.

  This updates the database with the contents of the supplied `TagSet`,
  which has no inherent relationship to the database.

  If `update_mode` is true
  named records which already exist will update from `te`,
  otherwise the conflict will raise a `ValueError`.

  *`SQLTags.infer_db_url(envvar=None, default_path=None)`*:
  Infer the database URL.

  Parameters:
  * `envvar`: environment variable to specify a default,
    default from `DBURL_ENVVAR` (`SQLTAGS_DBURL`).

  *`SQLTags.items(self, *, prefix=None)`*:
  Return an iterable of `(tagset_name,TagSet)`.
  Excludes unnamed `TagSet`s.

  Constrain the names to those starting with `prefix`
  if not `None`.

  *`SQLTags.keys(self, *, prefix=None)`*:
  Yield all the nonNULL names.

  Constrain the names to those starting with `prefix`
  if not `None`.

  *`SQLTags.metanode`*:
  The metadata node.

  *`SQLTags.startup_shutdown(self)`*:
  Open the ORM while the `SQLTags` is open.

  *`SQLTags.values(self, *, prefix=None)`*:
  Return an iterable of the named `TagSet`s.
  Excludes unnamed `TagSet`s.

  Constrain the names to those starting with `prefix`
  if not `None`.



  `sqltags` main command line utility.

  Usage summary:

      Usage: sqltags [-f db_url] subcommand [...]
        -f db_url SQLAlchemy database URL or filename.
                  Default from $SQLTAGS_DBURL (default '~/var/sqltags.sqlite').
        Subcommands:
          dbshell
            Start an interactive database shell.
          edit criteria...
            Edit the entities specified by criteria.
          export [-F format] [{tag[=value]|-tag}...]
            Export entities matching all the constraints.
            -F format Specify the export format, either CSV or FSTAGS.
          find [-o output_format] {tag[=value]|-tag}...
            List entities matching all the constraints.
            -o output_format
                        Use output_format as a Python format string to lay out
                        the listing.
                        Default: {localtime} {headline}
          help [-l] [subcommand-names...]
            Print help for subcommands.
            This outputs the full help for the named subcommands,
            or the short help for all subcommands if no names are specified.
            -l  Long help even if no subcommand-names provided.
          import [{-u|--update}] {-|srcpath}...
            Import CSV data in the format emitted by "export".
            Each argument is a file path or "-", indicating standard input.
            -u, --update  If a named entity already exists then update its tags.
                          Otherwise this will be seen as a conflict
                          and the import aborted.
          init
            Initialise the database.
            This includes defining the schema and making the root metanode.
          list [entity-names...]
            List entities and their tags.
          log [-c category,...] [-d when] [-D strptime] {-|headline} [tags...]
            Record entries into the database.
            If headline is '-', read headlines from standard input.
            -c categories
              Specify the categories for this log entry.
              The default is to recognise a leading CAT,CAT,...: prefix.
            -d when
              Use when, an ISO8601 date, as the log entry timestamp.
            -D strptime
              Read the time from the start of the headline
              according to the provided strptime specification.
          ls [entity-names...]
            List entities and their tags.
          orm define_schema
            Runs the ORM's `define_schema()` method, which creates missing tables
            and entity 0 if missing.
          shell
            Run a command prompt via cmd.Cmd using this command's subcommands.
          tag {-|entity-name} {tag[=value]|-tag}...
            Tag an entity with multiple tags.
            With the form "-tag", remove that tag from the direct tags.
            A entity-name named "-" indicates that entity-names should
            be read from the standard input.

  *`SQLTagsCommand.cmd_list(self, argv)`*:
  Usage: {cmd} [entity-names...]
  List entities and their tags.

  *`SQLTagsCommand.cmd_ls(self, argv)`*:
  Usage: {cmd} [entity-names...]
  List entities and their tags.



  A singleton `TagSet` attached to an `SQLTags` instance.

  As with the `TagSet` superclass,
  tag values can be any Python type.
  However, because we are storing these values in an SQL database
  it is necessary to provide a conversion facility
  to prepare those values for storage.

  The database schema is described in the `SQLTagsORM` class;
  in short we directly support `None`, `float` and `str`,
  `int`s which round trip with `float`,
  and `list`, `tuple` and `dict` whose contents transcribe to JSON.

  `int`s which are too large to round trip with `float`
  are treated as an extended `"bigint"` type
  using the scheme described below.

  Because the ORM has distinct `float` and `str` columns to support indexing,
  there will be no plain strings in the remaining JSON blob column.
  Therefore we support other types by providing functions
  to convert each type to a `str` and back,
  and an associated "type label" which will be prefixed to the string;
  the resulting string is stored in the JSON blob.

  The default mechanism is based on the following class attributes and methods:
  * `TYPE_JS_MAPPING`: a mapping of a type label string
    to a 3 tuple of `(type,to_str,from_str)`
    being the extended type,
    a function to convert an instance to `str`
    and a function to convert a `str` to an instance of this type
  * `to_js_str`: a method accepting `(tag_name,tag_value)`
    and returning `tag_value` as a `str`;
    the default implementation looks up the type of `tag_value`
    in `TYPE_JS_MAPPING` to locate the corresponding `to_str` function
  * `from_js_str`: a method accepting `(tag_name,js)`
    which uses the leading type label prefix from the `js`
    to look up the corresponding `from_str` function
    from `TYPE_JS_MAPPING` and use it on the tail of `js`

  The default `TYPE_JS_MAPPING` has mappings for:
  * `"bigint"`: conversions for `int`
  * `"date"`: conversions for `datetime.date`
  * `"datetime"`: conversions for `datetime.datetime`

  Subclasses wanting to augument the `TYPE_JS_MAPPING`
  should prepare their own with code such as:

      class SubSQLTagSet(SQLTagSet,....):
          ....
          TYPE_JS_MAPPING=dict(SQLTagSet.TYPE_JS_MAPPING)
          TYPE_JS_MAPPING.update(
            typelabel=(type, to_str, from_str),
            ....
          )

  *`SQLTagSet.add_db_tag(self, tag_name, pv: cs.sqltags.PolyValue)`*:
  Add a tag to the database.

  *`SQLTagSet.child_tagsets(self, tag_name='parent')`*:
  Return the child `TagSet`s as defined by their parent `Tag`,
  by default the `Tag` named `'parent'`.

  *`SQLTagSet.db_session(self, new=False)`*:
  Context manager to obtain a new session if required,
  just a shim for `self.sqltags.db_session`.

  *`SQLTagSet.discard_db_tag(self, tag_name: str, pv: Optional[cs.sqltags.PolyValue] = None)`*:
  Discard a tag from the database.

  *`SQLTagSet.from_js_str(tag_name: str, js: str)`*:
  Convert the `str` `js` to a `Tag` value.
  This is the reverse of `as_js_str`.

  Subclasses wanting extra type support
  should either:
  (usual approach) provide their own `TYPE_JS_MAPPING` class attribute
  as described at the top of this class
  or (for unusual requirements) override this method and also `to_js_str`.

  *`SQLTagSet.from_polyvalue(tag_name: str, pv: cs.sqltags.PolyValue)`*:
  Convert an SQL `PolyValue` to a tag value.

  This can be overridden by subclasses along with `to_polyvalue`.
  The `tag_name` is provided for context
  in case it should influence the normalisation.

  *`SQLTagSet.jsonable(value)`*:
  Convert `value` to a form which can be directly JSON serialised.

  In particular this converts non-list/set/tuple Sequences to lists
  and non-dict Mappings to dicts.

  Warning: this is not robust against cycles.

  *`SQLTagSet.name`*:
  Return the `.name`.

  *`SQLTagSet.parent_tagset(self, tag_name='parent')`*:
  Return the parent `TagSet` as defined by a `Tag`,
  by default the `Tag` named `'parent'`.

  *`SQLTagSet.to_js_str(tag_name: str, tag_value) -> str`*:
  Convert `tag_value` to a `str` suitable for storage in `structure_value`.
  This can be reversed by `from_js_str`.

  Subclasses wanting extra type support
  should either:
  (usual approach) provide their own `TYPE_JS_MAPPING` class attribute
  as described at the top of this class
  or (for unusual requirements) override this method and also `from_js_str`.

  *`SQLTagSet.to_polyvalue(tag_name: str, tag_value) -> cs.sqltags.PolyValue`*:
  Normalise `Tag` values for storage via SQL.
  Preserve things directly expressable in JSON.
  Convert other values via `to_js_str`.
  Return `PolyValue` for use with the SQL rows.



  The ORM for an `SQLTags`.

  The current implementation uses 3 tables:
  * `entities`: this has a NULLable `name`
    and `unixtime` UNIX timestamp;
    this is unique per `name` if the name is not NULL
  * `tags`: this has an `entity_id`, `name` and a value stored
    in one of three columns: `float_value`, `string_value` and
    `structured_value` which is a JSON blob;
    this is unique per `(entity_id,name)`
  * `tag_subvalues`: this is a broken out version of `tags`
    when `structured_value` is a sequence or mapping,
    breaking out the values one per row;
    this exists to support "tag contains value" lookups

  Tag values are stored as follows:
  * `None`: all 3 columns are set to `NULL`
  * `float`: stored in `float_value`
  * `int`: if the `int` round trips to `float`
    then it is stored in `float_value`,
    otherwise it is stored in `structured_value`
    with the type label `"bigint"`
  * `str`: stored in `string_value`
  * `list`, `tuple`, `dict`: stored in `structured_value`;
    if these containers contain unJSONable content there will be trouble
  * other types, such as `datetime`:
    these are converted to strings with identifying type label prefixes
    and stored in `structured_value`

  The `float_value` and `string_value` columns
  allow us to provide indices for these kinds of tag values.

  The type label scheme takes advantage of the fact that actual `str`s
  are stored in the `string_value` column.
  Because of this, there will be no actual strings in `structured_value`.
  Therefore, we can convert nonJSONable types to `str` and store them here.

  The scheme used is to provide conversion functions to convert types
  to `str` and back, and an associated "type label" prefix.
  For example, we store a `datetime` as the ISO format of the `datetime`
  with `"datetime:"` prefixed to it.

  The actual conversions are kept with the `SQLTagSet` class
  (or any subclass).
  This ORM receives the 3-tuples of SQL ready values
  from that class as the `PolyValue` `namedtuple`
  and does not perform any conversion itself.
  The conversion process is described in `SQLTagSet`.

  *`SQLTagsORM.declare_schema(self)`*:
  Define the database schema / ORM mapping.

  *`SQLTagsORM.prepare_metanode(self, *, session)`*:
  Ensure row id 0, the metanode, exists.

  *`SQLTagsORM.search(self, criteria, *, session, mode='tagged')`*:
  Construct a query to match `Entity` rows
  matching the supplied `criteria` iterable.
  Return an SQLAlchemy `Query`.

  The `mode` parameter has the following values:
  * `'id'`: the query only yields entity ids
  * `'entity'`: (default) the query yields entities without tags
  * `'tagged'`: (default) the query yields entities left outer
    joined with their matching tags

  Note that the `'tagged'` result produces multiple rows for any
  entity with multiple tags, and that this requires the caller to
  fold entities with multiple tags together.

  *Note*:
  due to implementation limitations
  the SQL query itself may not apply all the criteria,
  so every criterion must still be applied
  to the results
  using its `.match_entity` method.

  If `name` is omitted or `None` the query will match log entities
  otherwise the entity with the specified `name`.

  The `criteria` should be an iterable of `SQTCriterion` instances
  used to construct the query.



  Subclass of `TagSetCriterion` requiring an `.sql_parameters` method
  which returns an `SQLParameters` providing the information required
  to construct an sqlalchemy query.
  It also resets `.CRITERION_PARSE_CLASSES`, which will pick up
  the SQL capable criterion classes below.

  *`SQTCriterion.TAG_BASED_TEST_CLASS`*

  *`SQTCriterion.from_equality(tag_name, tag_value)`*:
  Return an `SQTCriterion` instance based on `tag_name==tag_value`.
  This supports `SQLTags.find`'s keyword parameters.

  *`SQTCriterion.match_tagged_entity(self, te: cs.tagset.TagSet) -> bool`*:
  Perform the criterion test on the Python object directly.
  This is used at the end of a query to implement tests which
  cannot be sufficiently implemented in SQL.
  If `self.SQL_COMPLETE` it is not necessary to call this method.

  *`SQTCriterion.sql_parameters(self, orm) -> cs.sqltags.SQLParameters`*:
  Subclasses must return am `SQLParameters` instance
  parameterising the SQL queries that follow.



  A test on `entity.id`.

  *`SQTEntityIdTest.match_tagged_entity(self, te: cs.tagset.TagSet) -> bool`*:
  Test the `TagSet` `te` against `self.entity_ids`.

  *`SQTEntityIdTest.parse(s, offset=0, delim=None)`*:
  Parse a decimal entity id from `s`.



  Emit message if in verbose mode.





  *Release 20240723*:
  * Replace many raises of RuntimeError with NotImplementedError, suggestion by @dimaqq on discuss.python.org.
  * Move some constants from BaseSQLTagsCommand to SQLTagsCommandsMixin where they belong, add missing USAGE_KEYWORDS entry.
  * SQLTagsORM: do not define_schema() in init, instead let the ORM do that and we prepare the metanode on first use of the db - this makes it much cheaper to make an SQLTags and then not use it.

  *Release 20240316*:
  Fixed release upload artifacts.

  *Release 20240305*:
  SQLTags: new .from_str so that we can inherit Promotable.promote.

  *Release 20240201.1*:
  Release with the "sqltags" script.

  *Release 20240201*:
  * SQLTagSet.to_polyvalue: treat sets like lists.
  * SQLTags.default_factory: honour new skip_refresh parameter, apply any presupplied tags.
  * Pull the cmd_* methods from BaseSQLTagsCommand into new SQLTagsCommandsMixin for reuse.

  *Release 20230612*:
  * SQLTagBasedTest.sql_parameters: fix general tag name.
  * SQLTagSet: new jsonable class method to produce a JSON serialisable object - converts sets and Sequences to flat lists, etc.

  *Release 20230217*:
  SQLTagsORM.search: previous changes seem to have dropped SQTCriterion support.

  *Release 20230212.1*:
  Mark SQLTags as promotable.

  *Release 20230212*:
  * @promote support for SQLTags, promoting a filesystem path to a .sqlite db.
  * Simpler SQLTagsORM.search comparison implementation.
  * SQLTagSet: inherit format attributes from superclasses (TagSet).
  * New BaseSQLTagsCommand.cmd_shell method.
  * New BaseSQLTagsCommand.cmd_orm method with "define_schema" subcommand to update the db schema.
  * SQLTagsORM.__init__: drop case_sensitive, no longer supported?
  * SQLTagsORM.__init__: always call define_schema, it seems there are scenarios where this does some necessary sqlalchemy prep.

  *Release 20221228*:
  SQLTagsCommand: update implementation of BaseCommand.run_context to use super().run_context().

  *Release 20220806*:
  * Bugfix for SQLTagsORM.search(mode='entity').
  * SQLTags.find: new _without_tags=False parameter to allow fast searches omitting the entity tags.

  *Release 20220606*:
  * New SQLTagsORM.Entities.add_new_tags method, use it in SQLTags.default_factory for bulk insert.
  * SQTCriterion: new .from_equality(tag_name,tag_value) factory to make an equality criterion.
  * SQLTags.find: accept criteria as positional parameters instead of a single iterable, accept new keyword parameters as equality criteria.
  * SQLTags.__getitem__: accept a slice to index the .unixtime tag.
  * SQLTagsORM: also turn on echo mode if "ECHO" in $SQLTAGS_MODES.

  *Release 20220311*:
  Assorted updates.

  *Release 20211212*:
  * Rename edit_many to edit_tagsets for clarity.
  * Small bugfixes.

  *Release 20210913*:
  * SQLTagsCommand: rename cmd_ns to cmd_list,cmd_ls.
  * SQLTagsCommand.cmd_export: accept "-F export_format" for csv or fstags export, accept no criteria to mean all tagsets.
  * Encoding schema for nonJSONable types.
  * Rename the TagSets abstract base class to BaseTagSets.
  * BaseSQLTagsCommand.cmd_edit: implement rename.
  * Many other internal small changes.

  *Release 20210420*:
  * New PolyValueMixin pulled out of Tags for common support of the (float_value,string_value,structured_value).
  * SQLTagsORM: new TagSubValues relation containing broken out values for values which are sequences, to support efficient lookup if sequence values such as log entry categories.
  * New BaseSQLTagsCommand.parse_categories static method to parse FOO,BAH into ['foo','bah'].
  * sqltags find: change default format to "{datetime} {headline}".
  * Assorted small changes.

  *Release 20210404*:
  * SQLTags.__getitem__: when autocreating an entity, do it in a new session so that the entity is commited to the database before any further use.
  * SQLTagsCommand: new cmd_dbshell to drop you into the database.

  *Release 20210321*:
  Drop logic now merged with cs.sqlalchemy_utils, use the new default session stuff.

  *Release 20210306.1*:
  Docstring updates.

  *Release 20210306*:
  Initial release.


pkgId: 8427c021abdd0ba9268e9780f6830dbbef50ad030f2699462e2a60fccb6d04ba
name: python-cs.tagset
arch: src
version: 20241007
epoch: 0
release: 1
summary: Tags and sets of tags with __format__ support and optional ontology information.
url: https://pypi.org/project/cs.tagset/
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cs.tagset-20241007-1.src.rpm
checksum_type: sha256
description:
  Tags and sets of tags
  with __format__ support and optional ontology information.

  *Latest release 20241007*:
  Tagset._Auto: act much more like a mapping.

  See `cs.fstags` for support for applying these to filesystem objects
  such as directories and files.

  See `cs.sqltags` for support for databases of entities with tags,
  not directly associated with filesystem objects.
  This is suited to both log entries (entities with no "name")
  and large collections of named entities;
  both accept `Tag`s and can be searched on that basis.

  All of the available complexity is optional:
  you can use `Tag`s without bothering with `TagSet`s
  or `TagsOntology`s.

  This module contains the following main classes:
  * `Tag`: an object with a `.name` and optional `.value` (default `None`)
    and also an optional reference `.ontology`
    for associating semantics with tag values.
    The `.value`, if not `None`, will often be a string,
    but may be any Python object.
    If you're using these via `cs.fstags`,
    the object will need to be JSON transcribeable.
  * `TagSet`: a `dict` subclass representing a set of `Tag`s
    to associate with something;
    it also has setlike `.add` and `.discard` methods.
    As such it only supports a single `Tag` for a given tag name,
    but that tag value can of course be a sequence or mapping
    for more elaborate tag values.
  * `TagsOntology`:
    a mapping of type names to `TagSet`s defining the type
    and also to entries for the metadata for specific per-type values.

  Here's a simple example with some `Tag`s and a `TagSet`.

      >>> tags = TagSet()
      >>> # add a "bare" Tag named 'blue' with no value
      >>> tags.add('blue')
      >>> # add a "topic=tagging" Tag
      >>> tags.set('topic', 'tagging')
      >>> # make a "subtopic" Tag and add it
      >>> subtopic = Tag('subtopic', 'ontologies')
      >>> tags.add(subtopic)
      >>> # Tags have nice repr() and str()
      >>> subtopic
      Tag(name='subtopic',value='ontologies')
      >>> print(subtopic)
      subtopic=ontologies
      >>> # a TagSet also has a nice repr() and str()
      >>> tags
      TagSet:{'blue': None, 'topic': 'tagging', 'subtopic': 'ontologies'}
      >>> print(tags)
      blue subtopic=ontologies topic=tagging
      >>> tags2 = TagSet({'a': 1}, b=3, c=[1,2,3], d='dee')
      >>> tags2
      TagSet:{'a': 1, 'b': 3, 'c': [1, 2, 3], 'd': 'dee'}
      >>> print(tags2)
      a=1 b=3 c=[1,2,3] d=dee
      >>> # since you can print a TagSet to a file as a line of text
      >>> # you can get it back from a line of text
      >>> TagSet.from_line('a=1 b=3 c=[1,2,3] d=dee')
      TagSet:{'a': 1, 'b': 3, 'c': [1, 2, 3], 'd': 'dee'}
      >>> # because TagSets are dicts you can format strings with them
      >>> print('topic:{topic} subtopic:{subtopic}'.format_map(tags))
      topic:tagging subtopic:ontologies
      >>> # TagSets have convenient membership tests
      >>> # test for blueness
      >>> 'blue' in tags
      True
      >>> # test for redness
      >>> 'red' in tags
      False
      >>> # test for any "subtopic" tag
      >>> 'subtopic' in tags
      True
      >>> # test for subtopic=ontologies
      >>> print(subtopic)
      subtopic=ontologies
      >>> subtopic in tags
      True
      >>> # test for subtopic=libraries
      >>> subtopic2 = Tag('subtopic', 'libraries')
      >>> subtopic2 in tags
      False



  `Tag`s and `TagSet`s suffice to apply simple annotations to things.
  However, an ontology brings meaning to those annotations.

  See the `TagsOntology` class for implementation details,
  access methods and more examples.

  Consider a record about a movie, with these tags (a `TagSet`):

      title="Avengers Assemble"
      series="Avengers (Marvel)"
      cast={"Scarlett Johansson":"Black Widow (Marvel)"}

  where we have the movie title,
  a name for the series in which it resides,
  and a cast as an association of actors with roles.

  An ontology lets us associate implied types and metadata with these values.

  Here's an example ontology supporting the above `TagSet`:

      type.cast type=dict key_type=person member_type=character description="members of a production"
      type.character description="an identified member of a story"
      type.series type=str
      character.marvel.black_widow type=character names=["Natasha Romanov"]
      person.scarlett_johansson fullname="Scarlett Johansson" bio="Known for Black Widow in the Marvel stories."

  The type information for a `cast`
  is defined by the ontology entry named `type.cast`,
  which tells us that a `cast` `Tag` is a `dict`,
  whose keys are of type `person`
  and whose values are of type `character`.
  (The default type is `str`.)

  To find out the underlying type for a `character`
  we look that up in the ontology in turn;
  because it does not have a specified `type` `Tag`, it it taken to be a `str`.

  Having the types for a `cast`,
  it is now possible to look up the metadata for the described cast members.

  The key `"Scarlett Johansson"` is a `person`
  (from the type definition of `cast`).
  The ontology entry for her is named `person.scarlett_johansson`
  which is computed as:
  * `person`: the type name
  * `scarlett_johansson`: obtained by downcasing `"Scarlett Johansson"`
    and replacing whitespace with an underscore.
    The full conversion process is defined
    by the `TagsOntology.value_to_tag_name` function.

  The key `"Black Widow (Marvel)"` is a `character`
  (again, from the type definition of `cast`).
  The ontology entry for her is named `character.marvel.black_widow`
  which is computed as:
  * `character`: the type name
  * `marvel.black_widow`: obtained by downcasing `"Black Widow (Marvel)"`,
    replacing whitespace with an underscore,
    and moving a bracketed suffix to the front as an unbracketed prefix.
    The full conversion process is defined
    by the `TagsOntology.value_to_tag_name` function.



  You can just use `str.format_map` as shown above
  for the direct values in a `TagSet`,
  since it subclasses `dict`.

  However, `TagSet`s also subclass `cs.lex.FormatableMixin`
  and therefore have a richer `format_as` method which has an extended syntax
  for the format component.
  Command line tools like `fstags` use this for output format specifications.

  An example:

      >>> # an ontology specifying the type for a colour
      >>> # and some information about the colour "blue"
      >>> ont = TagsOntology(
      ...   {
      ...       'type.colour':
      ...       TagSet(description="a colour, a hue", type="str"),
      ...       'colour.blue':
      ...       TagSet(
      ...           url='https://en.wikipedia.org/wiki/Blue',
      ...           wavelengths='450nm-495nm'
      ...       ),
      ...   }
      ... )
      >>> # tag set with a "blue" tag, using the ontology above
      >>> tags = TagSet(colour='blue', labels=['a', 'b', 'c'], size=9, _ontology=ont)
      >>> tags.format_as('The colour is {colour}.')
      'The colour is blue.'
      >>> # format a string about the tags showing some metadata about the colour
      >>> tags.format_as('Information about the colour may be found here: {colour:metadata.url}')
      'Information about the colour may be found here: https://en.wikipedia.org/wiki/Blue'



  Convert a tag value to a UNIX timestamp.

  This accepts `int`, `float` (already a timestamp)
  and `date` or `datetime`
  (use `datetime.timestamp() for a nonnaive `datetime`,
  otherwise `time.mktime(tag_value.time_tuple())`,
  which assumes the local time zone).



  Base class for collections of `TagSet` instances
  such as `cs.fstags.FSTags` and `cs.sqltags.SQLTags`.

  Examples of this include:
  * `cs.cdrip.MBSQLTags`: a mapping of MusicbrainsNG entities to their associated `TagSet`
  * `cs.fstags.FSTags`: a mapping of filesystem paths to their associated `TagSet`
  * `cs.sqltags.SQLTags`: a mapping of names to `TagSet`s stored in an SQL database

  Subclasses must implement:
  * `get(name,default=None)`: return the `TagSet` associated
    with `name`, or `default`.
  * `__setitem__(name,tagset)`: associate a `TagSet`with the key `name`;
    this is called by the `__missing__` method with a newly created `TagSet`.
  * `keys(self)`: return an iterable of names

  Subclasses may reasonably want to override the following:
  * `startup_shutdown(self)`: context manager to allocate and release any
    needed resources such as database connections

  Subclasses may implement:
  * `__len__(self)`: return the number of names

  The `TagSet` factory used to fetch or create a `TagSet` is
  named `TagSetClass`. The default implementation honours two
  class attributes:
  * `TAGSETCLASS_DEFAULT`: initially `TagSet`
  * `TAGSETCLASS_PREFIX_MAPPING`: a mapping of type names to `TagSet` subclasses

  The type name of a `TagSet` name is the first dotted component.
  For example, `artist.nick_cave` has the type name `artist`.
  A subclass of `BaseTagSets` could utiliise an `ArtistTagSet` subclass of `TagSet`
  and provide:

      TAGSETCLASS_PREFIX_MAPPING = {
        'artist': ArtistTagSet,
      }

  in its class definition. Accesses to `artist.`* entities would
  result in `ArtistTagSet` instances and access to other enitities
  would result in ordinary `TagSet` instances.

  *`BaseTagSets.__init__(self, *, ontology=None)`*:
  Initialise the collection.

  *`BaseTagSets.TAGSETCLASS_DEFAULT`*

  *`BaseTagSets.TagSetClass(self, *, name, **kw)`*:
  Factory to create a new `TagSet` from `name`.

  *`BaseTagSets.__contains__(self, name: str)`*:
  Test whether `name` is present in the underlying mapping.

  *`BaseTagSets.__getitem__(self, name: str)`*:
  Obtain the `TagSet` associated with `name`.

  If `name` is not presently mapped,
  return `self.__missing__(name)`.

  *`BaseTagSets.__iter__(self)`*:
  Iteration returns the keys.

  *`BaseTagSets.__len__(self)`*:
  Return the length of the underlying mapping.

  *`BaseTagSets.__missing__(self, name: str, **kw)`*:
  Like `dict`, the `__missing__` method may autocreate a new `TagSet`.

  This is called from `__getitem__` if `name` is missing
  and uses the factory `cls.default_factory`.
  If that is `None` raise `KeyError`,
  otherwise call `self.default_factory(name,**kw)`.
  If that returns `None` raise `KeyError`,
  otherwise save the entity under `name` and return the entity.

  *`BaseTagSets.__setitem__(self, name, te)`*:
  Save `te` in the backend under the key `name`.

  *`BaseTagSets.add(self, name: str, **kw)`*:
  Return a new `TagSet` associated with `name`,
  which should not already be in use.

  *`BaseTagSets.default_factory(self, name: str)`*:
  Create a new `TagSet` named `name`.

  *`BaseTagSets.edit(self, *, select_tagset=None, **kw)`*:
  Edit the `TagSet`s.

  Parameters:
  * `select_tagset`: optional callable accepting a `TagSet`
    which tests whether it should be included in the `TagSet`s
    to be edited
  Other keyword arguments are passed to `Tag.edit_tagsets`.

  *`BaseTagSets.get(self, name: str, default=None)`*:
  Return the `TagSet` associated with `name`,
  or `default` if there is no such entity.

  *`BaseTagSets.items(self, *, prefix=None)`*:
  Generator yielding `(key,value)` pairs,
  optionally constrained to keys starting with `prefix+'.'`.

  *`BaseTagSets.keys(self, *, prefix=None)`*:
  Return the keys starting with `prefix+'.'`
  or all keys if `prefix` is `None`.

  *`BaseTagSets.subdomain(self, subname: str)`*:
  Return a proxy for this `BaseTagSets` for the `name`s
  starting with `subname+'.'`.

  *`BaseTagSets.values(self, *, prefix=None)`*:
  Generator yielding the mapping values (`TagSet`s),
  optionally constrained to keys starting with `prefix+'.'`.



  Convert `obj` to a JSON encodable form.
  This returns `obj` for purely JSONable objects and a JSONable
  deep copy of `obj` if it or some subcomponent required
  conversion.
  `converted` is a dict mapping object ids to their converted forms
  to prevent loops.



  A `BaseTagSets` subclass using an arbitrary mapping.

  If no mapping is supplied, a `dict` is created for the purpose.

  Example:

      >>> tagsets = MappingTagSets()
      >>> list(tagsets.keys())
      []
      >>> tagsets.get('foo')
      >>> tagsets['foo'] = TagSet(bah=1, zot=2)
      >>> list(tagsets.keys())
      ['foo']
      >>> tagsets.get('foo')
      TagSet:{'bah': 1, 'zot': 2}
      >>> list(tagsets.keys(prefix='foo'))
      ['foo']
      >>> list(tagsets.keys(prefix='bah'))
      []

  *`MappingTagSets.__delitem__(self, name)`*:
  Delete the `TagSet` named `name`.

  *`MappingTagSets.__setitem__(self, name, te)`*:
  Save `te` in the backend under the key `name`.

  *`MappingTagSets.keys(self, *, prefix: Optional[str] = None)`*:
  Return an iterable of the keys commencing with `prefix`
  or all keys if `prefix` is `None`.



  A regular expression based `Tag` rule.

  This applies a regular expression to a string
  and returns inferred `Tag`s.

  *`RegexpTagRule.infer_tags(self, s)`*:
  Apply the rule to the string `s`, return a list of `Tag`s.



  Run some ad hoc self tests.



  A `Tag` has a `.name` (`str`) and a `.value`
  and an optional `.ontology`.

  The `name` must be a dotted identifier.

  Terminology:
  * A "bare" `Tag` has a `value` of `None`.
  * A "naive" `Tag` has an `ontology` of `None`.

  The constructor for a `Tag` is unusual:
  * both the `value` and `ontology` are optional,
    defaulting to `None`
  * if `name` is a `str` then we always construct a new `Tag`
    with the suppplied values
  * if `name` is not a `str`
    it should be a `Tag`like object to promote;
    it is an error if the `value` parameter is not `None`
    in this case
  * an optional `prefix` may be supplied
    which is prepended to `name` with a dot (`'.'`) if not empty

  The promotion process is as follows:
  * if `name` is a `Tag` subinstance
    then if the supplied `ontology` is not `None`
    and is not the ontology associated with `name`
    then a new `Tag` is made,
    otherwise the original `Tag` is returned unchanged
  * otherwise a new `Tag` is made from `name`
    using its `.value`
    and overriding its `.ontology`
    if the `ontology` parameter is not `None`

  Examples:

      >>> ont = TagsOntology({'colour.blue': TagSet(wavelengths='450nm-495nm')})
      >>> tag0 = Tag('colour', 'blue')
      >>> tag0
      Tag(name='colour',value='blue')
      >>> tag = Tag(tag0)
      >>> tag
      Tag(name='colour',value='blue')
      >>> tag = Tag(tag0, ontology=ont)
      >>> tag # doctest: +ELLIPSIS
      Tag(name='colour',value='blue',ontology=...)
      >>> tag = Tag(tag0, prefix='surface')
      >>> tag
      Tag(name='surface.colour',value='blue')

  *`Tag.__init__(self, *a, **kw)`*:
  Dummy `__init__` to avoid `FormatableMixin.__init__`
  because we subclass `namedtuple` which has no `__init__`.

  *`Tag.__hash__`*

  *`Tag.__str__(self)`*:
  Encode `name` and `value`.

  *`Tag.alt_values(self, value_tag_name=None)`*:
  Return a list of alternative values for this `Tag`
  on the premise that each has a metadata entry.

  *`Tag.basetype`*:
  The base type name for this tag.
  Returns `None` if there is no ontology.

  This calls `self.onotology.basetype(self.name)`.
  The basetype is the endpoint of a cascade down the defined types.

  For example, this might tell us that a `Tag` `role="Fred"`
  has a basetype `"str"`
  by cascading through a hypothetical chain `role`->`character`->`str`:

      type.role type=character
      type.character type=str

  *`Tag.from_arg(arg, offset=0, ontology=None)`*:
  Parse a `Tag` from the string `arg` at `offset` (default `0`).
  where `arg` is known to be entirely composed of the value,
  such as a command line argument.

  This calls the `from_str` method with `fallback_parse` set
  to gather then entire tail of the supplied string `arg`.

  *`Tag.from_str(s, offset=0, ontology=None, fallback_parse=None)`*:
  Parse a `Tag` definition from `s` at `offset` (default `0`).

  *`Tag.from_str2(s, offset=0, *, ontology=None, extra_types=None, fallback_parse=None)`*:
  Parse tag_name[=value], return `(Tag,offset)`.

  *`Tag.is_valid_name(name)`*:
  Test whether a tag name is valid: a dotted identifier.

  *`Tag.key_metadata(self, key)`*:
  Return the metadata definition for `key`.

  The metadata `TagSet` is obtained from the ontology entry
  *type*`.`*key_tag_name*
  where *type* is the `Tag`'s `key_type`
  and *key_tag_name* is the key converted
  into a dotted identifier by `TagsOntology.value_to_tag_name`.

  *`Tag.key_type`*:
  The type name for members of this tag.

  This is required if `.value` is a mapping.

  *`Tag.key_typedef`*:
  The typedata definition for this `Tag`'s keys.

  This is for `Tag`s which store mappings,
  for example a movie cast, mapping actors to roles.

  The name of the member type comes from
  the `key_type` entry from `self.typedata`.
  That name is then looked up in the ontology's types.

  *`Tag.matches(self, tag_name, value)`*:
  Test whether this `Tag` matches `(tag_name,value)`.

  *`Tag.member_metadata(self, member_key)`*:
  Return the metadata definition for self[member_key].

  The metadata `TagSet` is obtained from the ontology entry
  *type*`.`*member_tag_name*
  where *type* is the `Tag`'s `member_type`
  and *member_tag_name* is the member value converted
  into a dotted identifier by `TagsOntology.value_to_tag_name`.

  *`Tag.member_type`*:
  The type name for members of this tag.

  This is required if `.value` is a sequence or mapping.

  *`Tag.member_typedef`*:
  The typedata definition for this `Tag`'s members.

  This is for `Tag`s which store mappings or sequences,
  for example a movie cast, mapping actors to roles,
  or a list of scenes.

  The name of the member type comes from
  the `member_type` entry from `self.typedata`.
  That name is then looked up in the ontology's types.

  *`Tag.meta`*:
  Shortcut property for the metadata `TagSet`.

  *`Tag.metadata(self, *, ontology=None, convert=None)`*:
  Fetch the metadata information about this specific tag value,
  derived through the `ontology` from the tag name and value.
  The default `ontology` is `self.ontology`.

  For a scalar type (`int`, `float`, `str`) this is the ontology `TagSet`
  for `self.value`.

  For a sequence (`list`) this is a list of the metadata
  for each member.

  For a mapping (`dict`) this is mapping of `key->metadata`.

  *`Tag.parse_name(s, offset=0)`*:
  Parse a tag name from `s` at `offset`: a dotted identifier.

  *`Tag.parse_value(s, offset=0, *, extra_types=None, fallback_parse=None)`*:
  Parse a value from `s` at `offset` (default `0`).
  Return the value, or `None` on no data.

  The optional `extra_types` parameter may be an iterable of
  `(type,from_str,to_str)` tuples where `from_str` is a
  function which takes a string and returns a Python object
  (expected to be an instance of `type`).
  The default comes from `cls.EXTRA_TYPES`.
  This supports storage of nonJSONable values in text form.

  The optional `fallback_parse` parameter
  specifies a parse function accepting `(s,offset)`
  and returning `(parsed,new_offset)`
  where `parsed` is text from `s[offset:]`
  and `new_offset` is where the parse stopped.
  The default is `cs.lex.get_nonwhite`
  to gather nonwhitespace characters,
  intended to support *tag_name*`=`*bare_word*
  in human edited tag files.

  The core syntax for values is JSON;
  value text commencing with any of `'"'`, `'['` or `'{'`
  is treated as JSON and decoded directly,
  leaving the offset at the end of the JSON parse.

  Otherwise all the nonwhitespace at this point is collected
  as the value text,
  leaving the offset at the next whitespace character
  or the end of the string.
  The text so collected is then tried against the `from_str`
  function of each `extra_types`;
  the first successful parse is accepted as the value.
  If no extra type match,
  the text is tried against `int()` and `float()`;
  if one of these parses the text and `str()` of the result round trips
  to the original text
  then that value is used.
  Otherwise the text itself is kept as the value.

  *`Tag.transcribe_value(value, extra_types=None, json_options=None)`*:
  Transcribe `value` for use in `Tag` transcription.

  The optional `extra_types` parameter may be an iterable of
  `(type,from_str,to_str)` tuples where `to_str` is a
  function which takes a string and returns a Python object
  (expected to be an instance of `type`).
  The default comes from `cls.EXTRA_TYPES`.

  If `value` is an instance of `type`
  then the `to_str` function is used to transcribe the value
  as a `str`, which should not include any whitespace
  (because of the implementation of `parse_value`).
  If there is no matching `to_str` function,
  `cls.JSON_ENCODER.encode` is used to transcribe `value`.

  This supports storage of nonJSONable values in text form.

  *`Tag.typedef`*:
  The defining `TagSet` for this tag's name.

  This is how its type is defined,
  and is obtained from:
  `self.ontology['type.'+self.name]`

  Basic `Tag`s often do not need a type definition;
  these are only needed for structured tag values
  (example: a mapping of cast members)
  or when a `Tag` name is an alias for another type
  (example: a cast member name might be an `actor`
  which in turn might be a `person`).

  For example, a `Tag` `colour=blue`
  gets its type information from the `type.colour` entry in an ontology;
  that entry is just a `TagSet` with relevant information.



  A decorator for functions or methods which may be called as:

      func(name[,value])

  or as:

      func(Tag)

  The optional decorator argument `no_self` (default `False`)
  should be supplied for plain functions
  as they have no leading `self` parameter to accomodate.

  Example:

      @tag_or_tag_value
      def add(self, tag_name, value, *, verbose=None):

  This defines a `.add()` method
  which can be called with `name` and `value`
  or with single `Tag`like object
  (something with `.name` and `.value` attributes),
  for example:

      tags = TagSet()
      ....
      tags.add('colour', 'blue')
      ....
      tag = Tag('size', 9)
      tags.add(tag)



  A test based on a `Tag`.

  Attributes:
  * `spec`: the source text from which this choice was parsed,
    possibly `None`
  * `choice`: the apply/reject flag
  * `tag`: the `Tag` representing the criterion
  * `comparison`: an indication of the test comparison

  The following comparison values are recognised:
  * `None`: test for the presence of the `Tag`
  * `'='`: test that the tag value equals `tag.value`
  * `'<'`: test that the tag value is less than `tag.value`
  * `'<='`: test that the tag value is less than or equal to `tag.value`
  * `'>'`: test that the tag value is greater than `tag.value`
  * `'>='`: test that the tag value is greater than or equal to `tag.value`
  * `'~/'`: test if the tag value as a regexp is present in `tag.value`
  * '~': test if a matching tag value is present in `tag.value`

  *`TagBasedTest.by_tag_value(tag_name, tag_value, *, choice=True, comparison='=')`*:
  Return a `TagBasedTest` based on a `Tag` or `tag_name,tag_value`.

  *`TagBasedTest.match_tagged_entity(self, te: 'TagSet') -> bool`*:
  Test against the `Tag`s in `tags`.

  *Note*: comparisons when `self.tag.name` is not in `tags`
  always return `False` (possibly inverted by `self.choice`).

  *`TagBasedTest.parse(s, offset=0, delim=None)`*:
  Parse *tag_name*[{`<`|`<=`|'='|'>='|`>`|'~'}*value*]
  and return `(dict,offset)`
  where the `dict` contains the following keys and values:
  * `tag`: a `Tag` embodying the tag name and value
  * `comparison`: an indication of the test comparison



  A reference to a specific file containing tags.

  This manages a mapping of `name` => `TagSet`,
  itself a mapping of tag name => tag value.

  *`TagFile.__setitem__(self, name, te)`*:
  Set item `name` to `te`.

  *`TagFile.get(self, name, default=None)`*:
  Get from the tagsets.

  *`TagFile.is_modified(self)`*:
  Test whether this `TagSet` has been modified.

  *`TagFile.keys(self, *, prefix=None)`*:
  `tagsets.keys`

  If the options `prefix` is supplied,
  yield only those keys starting with `prefix`.

  *`TagFile.load_tagsets(filepath, ontology, extra_types=None)`*:
  Load `filepath` and return `(tagsets,unparsed)`.

  The returned `tagsets` are a mapping of `name`=>`tag_name`=>`value`.
  The returned `unparsed` is a list of `(lineno,line)`
  for lines which failed the parse (excluding the trailing newline).

  *`TagFile.names`*:
  The names from this `FSTagsTagFile` as a list.

  *`TagFile.parse_tags_line(line, ontology=None, verbose=None, extra_types=None) -> Tuple[str, cs.tagset.TagSet]`*:
  Parse a "name tags..." line as from a `.fstags` file,
  return `(name,TagSet)`.

  *`TagFile.save(self, extra_types=None, prune=False)`*:
  Save the tag map to the tag file if modified.

  *`TagFile.save_tagsets(filepath, tagsets, unparsed, extra_types=None, prune=False, update_mapping: Optional[Mapping] = None, update_prefix: Optional[str] = None, update_uuid_tag_name: Optional[str] = None)`*:
  Save `tagsets` and `unparsed` to `filepath`.

  This method will create the required intermediate directories
  if missing.

  This method *does not* clear the `.modified` attribute of the `TagSet`s
  because it does not know it is saving to the `Tagset`'s primary location.

  *`TagFile.startup_shutdown(self)`*:
  Save the tagsets if modified.

  *`TagFile.tags_line(name, tags, extra_types=None, prune=False)`*:
  Transcribe a `name` and its `tags` for use as a `.fstags` file line.

  *`TagFile.tagsets`*:
  The tag map from the tag file,
  a mapping of name=>`TagSet`.

  This is loaded on demand.

  *`TagFile.update(self, name, tags, *, prefix=None, verbose=None)`*:
  Update the tags for `name` from the supplied `tags`
  as for `Tagset.update`.



  Utility methods for `cs.cmdutils.BaseCommand` classes working with tags.

  Optional subclass attributes:
  * `TAGSET_CRITERION_CLASS`: a `TagSetCriterion` duck class,
    default `TagSetCriterion`.
    For example, `cs.sqltags` has a subclass
    with an `.extend_query` method for computing an SQL JOIN
    used in searching for tagged entities.

  *`TagsCommandMixin.TagAddRemove`*

  *`TagsCommandMixin.parse_tag_addremove(arg, offset=0)`*:
  Parse `arg` as an add/remove tag specification
  of the form [`-`]*tag_name*[`=`*value*].
  Return `(remove,Tag)`.

  Examples:

      >>> TagsCommandMixin.parse_tag_addremove('a')
      TagAddRemove(remove=False, tag=Tag(name='a',value=None))
      >>> TagsCommandMixin.parse_tag_addremove('-a')
      TagAddRemove(remove=True, tag=Tag(name='a',value=None))
      >>> TagsCommandMixin.parse_tag_addremove('a=1')
      TagAddRemove(remove=False, tag=Tag(name='a',value=1))
      >>> TagsCommandMixin.parse_tag_addremove('-a=1')
      TagAddRemove(remove=True, tag=Tag(name='a',value=1))
      >>> TagsCommandMixin.parse_tag_addremove('-a="foo bah"')
      TagAddRemove(remove=True, tag=Tag(name='a',value='foo bah'))
      >>> TagsCommandMixin.parse_tag_addremove('-a=foo bah')
      TagAddRemove(remove=True, tag=Tag(name='a',value='foo bah'))

  *`TagsCommandMixin.parse_tag_choices(argv)`*:
  Parse `argv` as an iterable of [`!`]*tag_name*[`=`*tag_value`] `Tag`
  additions/deletions.

  *`TagsCommandMixin.parse_tagset_criteria(argv, tag_based_test_class=None)`*:
  Parse tag specifications from `argv` until an unparseable item is found.
  Return `(criteria,argv)`
  where `criteria` is a list of the parsed criteria
  and `argv` is the remaining unparsed items.

  Each item is parsed via
  `cls.parse_tagset_criterion(item,tag_based_test_class)`.

  *`TagsCommandMixin.parse_tagset_criterion(arg, tag_based_test_class=None)`*:
  Parse `arg` as a tag specification
  and return a `tag_based_test_class` instance
  via its `.from_str` factory method.
  Raises `ValueError` in a misparse.
  The default `tag_based_test_class`
  comes from `cls.TAGSET_CRITERION_CLASS`,
  which itself defaults to class `TagSetCriterion`.

  The default `TagSetCriterion.from_str` recognises:
  * `-`*tag_name*: a negative requirement for *tag_name*
  * *tag_name*[`=`*value*]: a positive requirement for a *tag_name*
    with optional *value*.



  A setlike class associating a set of tag names with values.

  This actually subclasses `dict`, so a `TagSet` is a direct
  mapping of tag names to values.
  It accepts attribute access to simple tag values when they
  do not conflict with the class methods;
  the reliable method is normal item access.

  *NOTE*: iteration yields `Tag`s, not dict keys.

  Also note that all the `Tags` from a `TagSet`
  share its ontology.

  Subclasses should override the `set` and `discard` methods;
  the `dict` and mapping methods
  are defined in terms of these two basic operations.

  `TagSet`s have a few special properties:
  * `id`: a domain specific identifier;
    this may reasonably be `None` for entities
    not associated with database rows;
    the `cs.sqltags.SQLTags` class associates this
    with the database row id.
  * `name`: the entity's name;
    a read only alias for the `'name'` `Tag`.
    The `cs.sqltags.SQLTags` class defines "log entries"
    as `TagSet`s with no `name`.
  * `unixtime`: a UNIX timestamp,
    a `float` holding seconds since the UNIX epoch
    (midnight, 1 January 1970 UTC).
    This is typically the row creation time
    for entities associated with database rows,
    but usually the event time for `TagSet`s describing an event.

  Because ` TagSet` subclasses `cs.mappings.AttrableMappingMixin`
  you can also access tag values as attributes
  *provided* that they do not conflict with instance attributes
  or class methods or properties.

  *`TagSet.__init__(self, *a, _id=None, _ontology=None, **kw)`*:
  Initialise the `TagSet`.

  Parameters:
  * positional parameters initialise the `dict`
    and are passed to `dict.__init__`
  * `_id`: optional identity value for databaselike implementations
  * `_ontology`: optional `TagsOntology to use for this `TagSet`
  * other alphabetic keyword parameters are also used to initialise the
    `dict` and are passed to `dict.__init__`

  *`TagSet.__contains__(self, tag)`*:
  Test for a tag being in this `TagSet`.

  If the supplied `tag` is a `str` then this test
  is for the presence of `tag` in the keys.

  Otherwise,
  for each tag `T` in the tagset
  test `T.matches(tag)` and return `True` on success.
  The default `Tag.matches` method compares the tag name
  and if the same,
  returns true if `tag.value` is `None` (basic "is the tag present" test)
  and otherwise true if `tag.value==T.value` (basic "tag value equality" test).

  Otherwise return `False`.

  *`TagSet.__getattr__(self, attr)`*:
  Support access to dotted name attributes.

  The following attribute accesses are supported:
  - an attrbute from a superclass
  - a `Tag` whose name is `attr`; return its value
  - the value of `self.auto_infer(attr)` if that does not raise `ValueError`
  - if `self.ontology`, try {type}_{field} and {type}_{field}s
  - otherwise return `self.subtags(attr)` to allow access to dotted tags,
    provided any existing tags start with "attr."

  If this `TagSet` has an ontology
  and `attr looks like *typename*`_`*fieldname*
  and *typename* is a key,
  look up the metadata for the `Tag` value
  and return the metadata's *fieldname* key.
  This also works for plural values.

  For example if a `TagSet` has the tag `artists=["fred","joe"]`
  and `attr` is `artist_names`
  then the metadata entries for `"fred"` and `"joe"` are looked up
  and their `artist_name` tags are returned,
  perhaps resulting in the list
  `["Fred Thing","Joe Thang"]`.

  If there are keys commencing with `attr+'.'`
  then this returns a view of those keys
  so that a subsequent attribute access can access one of those keys.

  Otherwise, a superclass attribute access is performed.

  Example of dotted access to tags like `c.x`:

      >>> tags=TagSet(a=1,b=2)
      >>> tags.a
      1
      >>> tags.c
      Traceback (most recent call last):
          ...
      AttributeError: TagSet.c
      >>> tags['c.z']=9
      >>> tags['c.x']=8
      >>> tags
      TagSet:{'a': 1, 'b': 2, 'c.z': 9, 'c.x': 8}
      >>> tags.c
      TagSetPrefixView:c.{'z': 9, 'x': 8}
      >>> tags.c.z
      9

  However, this is not supported when there is a tag named `'c'`
  because `tags.c` has to return the `'c'` tag value:

      >>> tags=TagSet(a=1,b=2,c=3)
      >>> tags.a
      1
      >>> tags.c
      3
      >>> tags['c.z']=9
      >>> tags.c.z
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      AttributeError: 'int' object has no attribute 'z'

  *`TagSet.__iter__(self, prefix=None, ontology=None)`*:
  Yield the tag data as `Tag`s.

  *`TagSet.__setattr__(self, attr, value)`*:
  Attribute based `Tag` access.

  If `attr` is private or is in `self.__dict__` then that is updated,
  supporting "normal" attributes set on the instance.
  Otherwise the `Tag` named `attr` is set to `value`.

  The `__init__` methods of subclasses should do something like this
  (from `TagSet.__init__`)
  to set up the ordinary instance attributes
  which are not to be treated as `Tag`s:

      self.__dict__.update(id=_id, ontology=_ontology, modified=False)

  *`TagSet.__str__(self)`*:
  The `TagSet` suitable for writing to a tag file.

  *`TagSet.add(self, tag_name, value, **kw)`*:
  Adding a `Tag` calls the class `set()` method.

  *`TagSet.as_dict(self)`*:
  Return a `dict` mapping tag name to value.

  *`TagSet.as_tags(self, prefix=None, ontology=None)`*:
  Yield the tag data as `Tag`s.

  *`TagSet.auto`*:
  The automatic namespace.
  Here we can refer to dotted tag names directly as attributes.

  *`TagSet.auto_infer(self, attr)`*:
  The default inference implementation.

  This should return a value if `attr` is inferrable
  and raise `ValueError` if not.

  The default implementation returns the direct tag value for `attr`
  if present.

  *`TagSet.csvrow`*:
  This `TagSet` as a list useful to a `csv.writer`.
  The inverse of `from_csvrow`.

  *`TagSet.discard(self, tag_name, value, *, verbose=None)`*:
  Discard the tag matching `(tag_name,value)`.
  Return a `Tag` with the old value,
  or `None` if there was no matching tag.

  Note that if the tag value is `None`
  then the tag is unconditionally discarded.
  Otherwise the tag is only discarded
  if its value matches.

  *`TagSet.dump(self, keys=None, *, preindent=None, file=None, **pf_kwargs)`*:
  Dump a `TagSet` in multiline format.

  Parameters:
  * `keys`: optional iterable of `Tag` names to print
  * `file`: optional keyword parameter specifying the output filelike
    object; the default is `sys.stdout`.
  * `preindent`: optional leading indentation for the entire dump,
    either a `str` or an `int` indicating a number of spaces
  Other keyword arguments are passed to `pprint.pformat`.

  *`TagSet.edit(self, editor=None, verbose=None, comments=())`*:
  Edit this `TagSet`.

  *`TagSet.edit_tagsets(tes, editor=None, verbose=True)`*:
  Edit a collection of `TagSet`s.
  Return a list of `(old_name,new_name,TagSet)` for those which were modified.

  This function supports modifying both `name` and `Tag`s.
  The `Tag`s are updated directly.
  The changed names are returning in the `old_name,new_name` above.

  The collection `tes` may be either a mapping of name/key
  to `TagSet` or an iterable of `TagSets`. If the latter, a
  mapping is made based on `te.name or te.id` for each item
  `te` in the iterable.

  *`TagSet.from_csvrow(csvrow)`*:
  Construct a `TagSet` from a CSV row like that from
  `TagSet.csvrow`, being `unixtime,id,name,tags...`.

  *`TagSet.from_ini(f, section: str, missing_ok=False)`*:
  Load a `TagSet` from a section of a `.ini` file.

  Parameters:
  * `f`: the `.ini` format file to read;
    an iterable of lines (eg a file object)
    or the name of a file to open
  * `section`: the name of the config section
    from which to load the `TagSet`
  * `missing_ok`: optional flag, default `False`;
    if true a missing file will return an empty `TagSet`
    instead of raising `FileNotFoundError`

  *`TagSet.from_line(line, offset=0, *, ontology=None, extra_types=None, verbose=None)`*:
  Create a new `TagSet` from a line of text.

  *`TagSet.from_tags(tags, _id=None, _ontology=None)`*:
  Make a `TagSet` from an iterable of `Tag`s.

  *`TagSet.get_arg_name(self, field_name)`*:
  Override for `FormattableMixin.get_arg_name`:
  return the leading dotted identifier,
  which represents a tag or tag prefix.

  *`TagSet.get_value(self, arg_name, a, kw)`*:
  Override for `FormattableMixin.get_value`:
  look up `arg_name` in `kw`, return a value.

  The value is obtained as follows:
  * `kw[arg_name]`: the `Tag` named `arg_name` if present
  * `kw.get_format_attribute(arg_name)`:
    a formattable attribute named `arg_name`
  otherwise raise `KeyError` if `self.format_mode.strict`
  otherwise return the placeholder string `'{'+arg_name+'}'`.

  *`TagSet.is_stale(self, max_age=None)`*:
  Test whether this `TagSet` is stale
  i.e. the time since `self.last_updated` UNIX time exceeds `max_age` seconds
  (default from `self.STALE_AGE`).

  This is a convenience function for `TagSet`s which cache external data.

  *`TagSet.name`*:
  Read only `name` property, `None` if there is no `'name'` tag.

  *`TagSet.save_as_ini(self, f, section: str, config=None)`*:
  Save this `TagSet` to the config file `f` as `section`.

  If `f` is a string, read an existing config from that file
  and update the section.

  *`TagSet.set(self, tag_name, value, *, verbose=None)`*:
  Set `self[tag_name]=value`.
  If `verbose`, emit an info message if this changes the previous value.

  *`TagSet.set_from(self, other, verbose=None)`*:
  Completely replace the values in `self`
  with the values from `other`,
  a `TagSet` or any other `name`=>`value` dict.

  This has the feature of logging changes
  by calling `.set` and `.discard` to effect the changes.

  *`TagSet.subtags(self, prefix, as_tagset=False)`*:
  Return `TagSetPrefixView` of the tags commencing with `prefix+'.'`
  with the key prefixes stripped off.

  If `as_tagset` is true (default `False`)
  return a new standalone `TagSet` containing the prefixed keys.

  Example:

      >>> tags = TagSet({'a.b':1, 'a.d':2, 'c.e':3})
      >>> tags.subtags('a')
      TagSetPrefixView:a.{'b': 1, 'd': 2}
      >>> tags.subtags('a', as_tagset=True)
      TagSet:{'b': 1, 'd': 2}

  *`TagSet.tag(self, tag_name, prefix=None, ontology=None)`*:
  Return a `Tag` for `tag_name`, or `None` if missing.

  Parameters:
  * `tag_name`: the name of the `Tag` to create
  * `prefix`: optional prefix;
    if supplied, prepend `prefix+'.'` to the `Tag` name
  * `ontology`: optional ontology for the `Tag`,
    default `self.ontology`

  *`TagSet.tag_metadata(self, tag_name, prefix=None, ontology=None, convert=None)`*:
  Return a list of the metadata for the `Tag` named `tag_name`,
  or an empty list if the `Tag` is missing.

  *`TagSet.unixtime`*:
  `unixtime` property, autosets to `time.time()` if accessed and missing.

  *`TagSet.update(self, other=None, *, prefix=None, verbose=None, **kw)`*:
  Update this `TagSet` from `other`,
  a dict of `{name:value}`
  or an iterable of `Tag`like or `(name,value)` things.

  *`TagSet.uuid`*:
  The `TagSet`'s `'uuid'` value as a UUID if present, otherwise `None`.



  A testable criterion for a `TagSet`.

  *`TagSetCriterion.TAG_BASED_TEST_CLASS`*

  *`TagSetCriterion.from_any(o)`*:
  Convert some suitable object `o` into a `TagSetCriterion`.

  Various possibilities for `o` are:
  * `TagSetCriterion`: returned unchanged
  * `str`: a string tests for the presence
    of a tag with that name and optional value;
  * an object with a `.choice` attribute;
    this is taken to be a `TagSetCriterion` ducktype and returned unchanged
  * an object with `.name` and `.value` attributes;
    this is taken to be `Tag`-like and a positive test is constructed
  * `Tag`: an object with a `.name` and `.value`
    is equivalent to a positive equality `TagBasedTest`
  * `(name,value)`: a 2 element sequence
    is equivalent to a positive equality `TagBasedTest`

  *`TagSetCriterion.from_arg(arg, fallback_parse=None)`*:
  Prepare a `TagSetCriterion` from the string `arg`
  where `arg` is known to be entirely composed of the value,
  such as a command line argument.

  This calls the `from_str` method with `fallback_parse` set
  to gather then entire tail of the supplied string `arg`.

  *`TagSetCriterion.from_str(s: str, fallback_parse=None)`*:
  Prepare a `TagSetCriterion` from the string `s`.

  *`TagSetCriterion.from_str2(s, offset=0, delim=None, fallback_parse=None)`*:
  Parse a criterion from `s` at `offset` and return `(TagSetCriterion,offset)`.

  This method recognises an optional leading `'!'` or `'-'`
  indicating negation of the test,
  followed by a criterion recognised by the `.parse` method
  of one of the classes in `cls.CRITERION_PARSE_CLASSES`.

  *`TagSetCriterion.match_tagged_entity(self, te: 'TagSet') -> bool`*:
  Apply this `TagSetCriterion` to a `TagSet`.



  A view of a `TagSet` via a `prefix`.

  Access to a key `k` accesses the `TagSet`
  with the key `prefix+'.'+k`.

  This is a kind of funny hybrid of a `Tag` and a `TagSet`
  in that some things such as `__format__`
  will format the `Tag` named `prefix` if it exists
  in preference to the subtags.

  Example:

      >>> tags = TagSet(a=1, b=2)
      >>> tags
      TagSet:{'a': 1, 'b': 2}
      >>> tags['sub.x'] = 3
      >>> tags['sub.y'] = 4
      >>> tags
      TagSet:{'a': 1, 'b': 2, 'sub.x': 3, 'sub.y': 4}
      >>> sub = tags.sub
      >>> sub
      TagSetPrefixView:sub.{'x': 3, 'y': 4}
      >>> sub.z = 5
      >>> sub
      TagSetPrefixView:sub.{'x': 3, 'y': 4, 'z': 5}
      >>> tags
      TagSet:{'a': 1, 'b': 2, 'sub.x': 3, 'sub.y': 4, 'sub.z': 5}

  *`TagSetPrefixView.__getattr__(self, attr)`*:
  Proxy other attributes through to the `TagSet`.

  *`TagSetPrefixView.__setattr__(self, attr, value)`*:
  Attribute based `Tag` access.

  If `attr` is in `self.__dict__` then that is updated,
  supporting "normal" attributes set on the instance.
  Otherwise the `Tag` named `attr` is set to `value`.

  The `__init__` methods of subclasses should do something like this
  (from `TagSet.__init__`)
  to set up the ordinary instance attributes
  which are not to be treated as `Tag`s:

      self.__dict__.update(id=_id, ontology=_ontology, modified=False)

  *`TagSetPrefixView.as_dict(self)`*:
  Return a `dict` representation of this view.

  *`TagSetPrefixView.get(self, k, default=None)`*:
  Mapping `get` method.

  *`TagSetPrefixView.get_format_attribute(self, attr)`*:
  Fetch a formatting attribute from the proxied object.

  *`TagSetPrefixView.items(self)`*:
  Return an iterable of the items (`Tag` name, `Tag`).

  *`TagSetPrefixView.keys(self)`*:
  The keys of the subtags.

  *`TagSetPrefixView.ontology`*:
  The ontology of the references `TagSet`.

  *`TagSetPrefixView.setdefault(self, k, v=None)`*:
  Mapping `setdefault` method.

  *`TagSetPrefixView.subtags(self, subprefix)`*:
  Return a deeper view of the `TagSet`.

  *`TagSetPrefixView.tag`*:
  The `Tag` for the prefix, or `None` if there is no such `Tag`.

  *`TagSetPrefixView.update(self, mapping)`*:
  Update tags from a name->value mapping.

  *`TagSetPrefixView.value`*:
  Return the `Tag` value for the prefix, or `None` if there is no such `Tag`.

  *`TagSetPrefixView.values(self)`*:
  Return an iterable of the values (`Tag`s).



  A view into a `BaseTagSets` for keys commencing with a prefix
  being the subdomain plus a dot (`'.'`).

  *`TagSetsSubdomain.TAGGED_ENTITY_FACTORY`*:
  The entity factory comes from the parent collection.



  An ontology for tag names.
  This is based around a mapping of names
  to ontological information expressed as a `TagSet`.

  Normally an object's tags are not a self contained repository of all the information;
  instead a tag just names some information.

  As a example, consider the tag `colour=blue`.
  Meta information about `blue` is obtained via the ontology,
  which has an entry for the colour `blue`.
  We adopt the convention that the type is just the tag name,
  so we obtain the metadata by calling `ontology.metadata(tag)`
  or alternatively `ontology.metadata(tag.name,tag.value)`
  being the type name and value respectively.

  The ontology itself is based around `TagSets` and effectively the call
  `ontology.metadata('colour','blue')`
  would look up the `TagSet` named `colour.blue` in the underlying `Tagsets`.

  For a self contained dataset this means that it can be its own ontology.
  For tags associated with arbitrary objects
  such as the filesystem tags maintained by `cs.fstags`
  the ontology would be a separate tags collection stored in a central place.

  There are two main categories of entries in an ontology:
  * metadata: other entries named *typename*`.`*value_key*
    contains a `TagSet` holding metadata for a value of type *typename*
    whose value is mapped to *value_key*
  * types: an optional entry named `type.`*typename* contains a `TagSet`
    describing the type named *typename*;
    really this is just more metadata where the "type name" is `type`

  Metadata are `TagSets` instances describing particular values of a type.
  For example, some metadata for the `Tag` `colour="blue"`:

      colour.blue url="https://en.wikipedia.org/wiki/Blue" wavelengths="450nm-495nm"

  Some metadata associated with the `Tag` `actor="Scarlett Johansson"`:

      actor.scarlett_johansson role=["Black Widow (Marvel)"]
      character.marvel.black_widow fullname=["Natasha Romanov"]

  The tag values are lists above because an actor might play many roles, etc.

  There's a convention for converting human descriptions
  such as the role string `"Black Widow (Marvel)"` to its metadata.
  * the value `"Black Widow (Marvel)"` if converted to a key
    by the ontology method `value_to_tag_name`;
    it moves a bracket suffix such as `(Marvel)` to the front as a prefix
    `marvel.` and downcases the rest of the string and turns spaces into underscores.
    This yields the value key `marvel.black_widow`.
  * the type is `role`, so the ontology entry for the metadata
    is `role.marvel.black_widow`

  This requires type information about a `role`.
  Here are some type definitions supporting the above metadata:

      type.person type=str description="A person."
      type.actor type=person description="An actor's stage name."
      type.character type=str description="A person in a story."
      type.role type_name=character description="A character role in a performance."
      type.cast type=dict key_type=actor member_type=role description="Cast members and their roles."

  The basic types have their Python names: `int`, `float`, `str`, `list`,
  `dict`, `date`, `datetime`.
  You can define subtypes of these for your own purposes
  as illustrated above.

  For example:

      type.colour type=str description="A hue."

  which subclasses `str`.

  Subtypes of `list` include a `member_type`
  specifying the type for members of a `Tag` value:

      type.scene type=list member_type=str description="A movie scene."

  Subtypes of `dict` include a `key_type` and a `member_type`
  specifying the type for keys and members of a `Tag` value:

  Accessing type data and metadata:

  A `TagSet` may have a reference to a `TagsOntology` as `.ontology`
  and so also do any of its `Tag`s.

  *`TagsOntology.__bool__(self)`*:
  Support easy `ontology or some_default` tests,
  since ontologies are broadly optional.

  *`TagsOntology.__delitem__(self, name)`*:
  Delete the entity named `name`.

  *`TagsOntology.__getitem__(self, name)`*:
  Fetch `tags` for the entity named `name`.

  *`TagsOntology.__setitem__(self, name, tags)`*:
  Apply `tags` to the entity named `name`.

  *`TagsOntology.add_tagsets(self, tagsets: cs.tagset.BaseTagSets, match, unmatch=None, index=0)`*:
  Insert a `_TagsOntology_SubTagSets` at `index`
  in the list of `_TagsOntology_SubTagSets`es.

  The new `_TagsOntology_SubTagSets` instance is initialised
  from the supplied `tagsets`, `match`, `unmatch` parameters.

  *`TagsOntology.as_dict(self)`*:
  Return a `dict` containing a mapping of entry names to their `TagSet`s.

  *`TagsOntology.basetype(self, typename)`*:
  Infer the base type name from a type name.
  The default type is `'str'`,
  but any type which resolves to one in `self.BASE_TYPES`
  may be returned.

  *`TagsOntology.by_type(self, type_name, with_tagsets=False)`*:
  Yield keys or (key,tagset) of type `type_name`
  i.e. all keys commencing with *type_name*`.`.

  *`TagsOntology.convert_tag(self, tag)`*:
  Convert a `Tag`'s value accord to the ontology.
  Return a new `Tag` with the converted value
  or the original `Tag` unchanged.

  This is primarily aimed at things like regexp based autotagging,
  where the matches are all strings
  but various fields have special types,
  commonly `int`s or `date`s.

  *`TagsOntology.edit_indices(self, indices, prefix=None)`*:
  Edit the entries specified by indices.
  Return `TagSet`s for the entries which were changed.

  *`TagsOntology.from_match(tagsets, match, unmatch=None)`*:
  Initialise a `SubTagSets` from `tagsets`, `match` and optional `unmatch`.

  Parameters:
  * `tagsets`: a `TagSets` holding ontology information
  * `match`: a match function used to choose entries based on a type name
  * `unmatch`: an optional reverse for `match`, accepting a subtype
    name and returning its public name

  If `match` is `None`
  then `tagsets` will always be chosen if no prior entry matched.

  Otherwise, `match` is resolved to a function `match-func(type_name)`
  which returns a subtype name on a match and a false value on no match.

  If `match` is a callable it is used as `match_func` directly.

  if `match` is a list, tuple or set
  then this method calls itself with `(tagsets,submatch)`
  for each member `submatch` if `match`.

  If `match` is a `str`,
  if it ends in a dot '.', dash '-' or underscore '_'
  then it is considered a prefix of `type_name` and the returned
  subtype name is the text from `type_name` after the prefix
  othwerwise it is considered a full match for the `type_name`
  and the returns subtype name is `type_name` unchanged.
  The `match` string is a simplistic shell style glob
  supporting `*` but not `?` or `[`*seq*`]`.

  The value of `unmatch` is constrained by `match`.
  If `match` is `None`, `unmatch` must also be `None`;
  the type name is used unchanged.
  If `match` is callable`, `unmatch` must also be callable;
  it is expected to reverse `match`.

  Examples:

      >>> from cs.sqltags import SQLTags
      >>> from os.path import expanduser as u
      >>> # an initial empty ontology with a default in memory mapping
      >>> ont = TagsOntology()
      >>> # divert the types actor, role and series to my media ontology
      >>> ont.add_tagsets(
      ...     SQLTags(u('~/var/media-ontology.sqlite')),
      ...     ['actor', 'role', 'series'])
      >>> # divert type "musicbrainz.recording" to mbdb.sqlite
      >>> # mapping to the type "recording"
      >>> ont.add_tagsets(SQLTags(u('~/.cache/mbdb.sqlite')), 'musicbrainz.')
      >>> # divert type "tvdb.actor" to tvdb.sqlite
      >>> # mapping to the type "actor"
      >>> ont.add_tagsets(SQLTags(u('~/.cache/tvdb.sqlite')), 'tvdb.')

  *`TagsOntology.get(self, name, default=None)`*:
  Fetch the entity named `name` or `default`.

  *`TagsOntology.items(self)`*:
  Yield `(entity_name,tags)` for all the items in each subtagsets.

  *`TagsOntology.keys(self)`*:
  Yield entity names for all the entities.

  *`TagsOntology.metadata(self, type_name, value, *, convert=None)`*:
  Return the metadata `TagSet` for `type_name` and `value`.
  This implements the mapping between a type's value and its semantics.

  The optional parameter `convert`
  may specify a function to use to convert `value` to a tag name component
  to be used in place of `self.value_to_tag_name` (the default).

  For example, if a `TagSet` had a list of characters such as:

      character=["Captain America (Marvel)","Black Widow (Marvel)"]

  then these values could be converted to the dotted identifiers
  `character.marvel.captain_america`
  and `character.marvel.black_widow` respectively,
  ready for lookup in the ontology
  to obtain the "metadata" `TagSet` for each specific value.

  *`TagsOntology.startup_shutdown(self)`*:
  Open all the sub`TagSets` and close on exit.

  *`TagsOntology.subtype_name(self, type_name)`*:
  Return the type name for use within `self.tagsets` from `type_name`.
  Returns `None` if this is not a supported `type_name`.

  *`TagsOntology.type_name(self, subtype_name)`*:
  Return the external type name from the internal `subtype_name`
  which is used within `self.tagsets`.

  *`TagsOntology.type_names(self)`*:
  Return defined type names i.e. all entries starting `type.`.

  *`TagsOntology.type_values(self, type_name, value_tag_name=None)`*:
  Yield the various defined values for `type_name`.
  This is useful for types with enumerated metadata entries.

  For example, if metadata entries exist as `foo.bah` and `foo.baz`
  for the `type_name` `'foo'`
  then this yields `'bah'` and `'baz'`.`

  Note that this looks for a `Tag` for the value,
  falling back to the entry suffix if the tag is not present.
  That tag is normally named `value`
  (from DEFAULT_VALUE_TAG_NAME)
  but may be overridden by the `value_tag_name` parameter.
  Also note that normally it is desireable that the value
  convert to the suffix via the `value_to_tag_name` method
  so that the metadata entry can be located from the value.

  *`TagsOntology.typedef(self, type_name)`*:
  Return the `TagSet` defining the type named `type_name`.

  *`TagsOntology.types(self)`*:
  Generator yielding defined type names and their defining `TagSet`.

  *`TagsOntology.value_to_tag_name(value)`*:
  Convert a tag value to a tagnamelike dotted identifierish string
  for use in ontology lookup.
  Raises `ValueError` for unconvertable values.

  We are allowing dashes in the result (UUIDs, MusicBrainz discids, etc).

  `int`s are converted to `str`.

  Strings are converted as follows:
  * a trailing `(.*)` is turned into a prefix with a dot,
    for example `"Captain America (Marvel)"`
    becomes `"Marvel.Captain America"`.
  * the string is split into words (nonwhitespace),
    lowercased and joined with underscores,
    for example `"Marvel.Captain America"`
    becomes `"marvel.captain_america"`.



  A command line for working with ontology types.

  Usage summary:

      Usage: tagsontology subcommand [options...]
        A command line for working with ontology types.
        Subcommands:
          edit [{/name-regexp | entity-name}]
            Edit entities.
            With no arguments, edit all the entities.
            With an argument starting with a slash, edit the entities
            whose names match the regexp.
            Otherwise the argument is expected to be an entity name;
            edit the tags of that entity.
          help [-l] [subcommand-names...]
            Print help for subcommands.
            This outputs the full help for the named subcommands,
            or the short help for all subcommands if no names are specified.
            -l  Long help even if no subcommand-names provided.
          meta tag=value
          shell
            Run a command prompt via cmd.Cmd using this command's subcommands.
          type
              With no arguments, list the defined types.
            type type_name
              With a type name, print its `Tag`s.
            type type_name edit
              Edit the tags defining a type.
            type type_name edit meta_names_pattern...
              Edit the tags for the metadata names matching the
              meta_names_patterns.
            type type_name list
            type type_name ls
              List the metadata names for this type and their tags.
            type type_name + entity_name [tags...]
              Create type_name.entity_name and apply the tags.

  *`TagsOntologyCommand.cmd_edit(self, argv)`*:
  Usage: {cmd} [{{/name-regexp | entity-name}}]
  Edit entities.
  With no arguments, edit all the entities.
  With an argument starting with a slash, edit the entities
  whose names match the regexp.
  Otherwise the argument is expected to be an entity name;
  edit the tags of that entity.

  *`TagsOntologyCommand.cmd_meta(self, argv)`*:
  Usage: {cmd} tag=value

  *`TagsOntologyCommand.cmd_type(self, argv)`*:
  Usage:
  {cmd}
    With no arguments, list the defined types.
  {cmd} type_name
    With a type name, print its `Tag`s.
  {cmd} type_name edit
    Edit the tags defining a type.
  {cmd} type_name edit meta_names_pattern...
    Edit the tags for the metadata names matching the
    meta_names_patterns.
  {cmd} type_name list
  {cmd} type_name ls
    List the metadata names for this type and their tags.
  {cmd} type_name + entity_name [tags...]
    Create type_name.entity_name and apply the tags.





  *Release 20241007*:
  Tagset._Auto: act much more like a mapping.

  *Release 20241005*:
  _FormatStringTagProxy: give it a __format__ method which formats the proxied tag's value.

  *Release 20240422.2*:
  jsonable: use obj.for_json() if available.

  *Release 20240422.1*:
  jsonable: convert pathlib.PurePath to str, hoping this isn't too open ended a can of worms.

  *Release 20240422*:
  * New jsonable(obj) function to return a deep copy of `obj` which can be transcribed as JSON.
  * Tag.transcribe_value: pass jsonable(value) to the JSON encoder, drop special checks now done by jsonable().
  * Tag.__str__: do not catch TypeError any more, was embedding Python repr()s in .fstags files - now Tag.transcribe_value() does the correct thing where that is possible.

  *Release 20240316*:
  Fixed release upload artifacts.

  *Release 20240305*:
  * Tag.from_str2: make the ontology optional.
  * TagSetPrefixView: provide __len__() and update().

  *Release 20240211*:
  * TagFile.parse_tag_line: recognise dotted_identifiers directly, avoids misparsing bare "nan" as float NaN.
  * Tag.parse_value: BUGFIX parse - always to the primary types first (int, float) before trying any funny extra types.

  *Release 20240201*:
  TagsOntology.metadata: actually call the .items() method!

  *Release 20231129*:
  * TagSet.__getattr__: rework the attribute lookup with greater precision.
  * TagSetPrefixView.__getattr__: if the attribute is not there, raise Attribute error, do not try to fall back to something else.
  * TagSet: drop ATTRABLE_MAPPING_DEFAULT=None, caused far more confusion that it was worth.

  *Release 20230612*:
  * TagFile.save_tagsets: catch and warn about exceptions from update_mapping[key].update, something is wrong with my SQLTags usage.
  * TagFile.save_tagsets: update_mapping: do not swallow AttributeError.

  *Release 20230407*:
  Move the (optional) ORM open/close from FSTags.startup_shutdown to TagFile.save, greatly shortens the ORM lock.

  *Release 20230212*:
  Mark TagSetCriterion as Promotable.

  *Release 20230210*:
  * TagFile: new optional update_mapping secondary mapping to which to mirror file tags, for example to an SQLTags.
  * New .uuid:UUID property returning the UUID for the tag named 'uuid' or None.

  *Release 20230126*:
  New TagSet.is_stale() method based on .expiry attribute, intended for TagSets which are caches of other primary data.

  *Release 20221228*:
  * TagFile: drop _singleton_key, FSPathBasedSingleton provides a good default.
  * TagFile.save_tagsets,tags_line: new optional prune=False parameter to drop empty top level dict/lists.
  * TagFile.save: plumb prune=False parameter.

  *Release 20220806*:
  New TagSetCriterion.promote(obj)->TagSetCriterion class method.

  *Release 20220606*:
  * Tag.parse_value: bugfix parse of float.
  * TagSet.edit: accept optional comments parameter with addition header comment lines, be more tolerant of errors, avoid losing data on error.

  *Release 20220430*:
  * TagSetPrefixView: new as_dict() method.
  * TagSetPrefixView.__str__: behave like TagSet.__str__.
  * TagFile.save_tagsets: do not try to save if the file is missing and the tagsets are empty.
  * New TagSet.from_tags(tags) factory to make a new TagSet from an iterable of tags.
  * TagSetPrefixView: add .get and .setdefault mapping methods.
  * RegexpTagRule: accept optional tag_prefix parameter.
  * Tagset: new from_ini() and save_as_ini() methods to support cs.timeseries config files, probably handy elsewhere.

  *Release 20220311*:
  Assorted internal changes.

  *Release 20211212*:
  * Tag: new fallback_parse parameter for value parsing, default get_nonwhite.
  * Tag: new from_arg factory with fallback_parse grabbing the whole string for command line arguments, thus supporting unquoted strings for ease of use.
  * TagSetCriterion: new optional fallback_parse parameter and from_arg method as for the Tag factories.
  * Tag.transcribe_value: accept optional json_options to control the JSON encoder, used for human friendly multiline edits in cs.app.tagger.
  * Rename edit_many to edit_tagsets for clarity.
  * TagsOntology: new type_values method to return values for a type (derived from their metadata entries).
  * Tag: new alt_values method returning its TagsOntology.type_values.
  * (Internal) New _FormatStringTagProxy which proxies a Tag but uses str(self.__proxied.value) for __str__ to support format strings.
  * (Internal) TagSet.get_value: if arg_name matches a Tag, return a _FormatStringTagProxy.
  * Tag.__new__: accept (tag_name,value) or (Tag) as initialisation parameters.

  *Release 20210913*:
  * TagSet.get_value: raise KeyError in strict mode, leave placeholder otherwise.
  * Other small changes.

  *Release 20210906*:
  Many many updates; some semantics have changed.

  *Release 20210428*:
  Bugfix TagSet.set: internal in place changes to a complex tag value were not noticed, causing TagFile to not update on shutdown.

  *Release 20210420*:
  * TagSet: also subclass cs.dateutils.UNIXTimeMixin.
  * Various TagSetNamespace updates and bugfixes.

  *Release 20210404*:
  Bugfix TagBasedTest.COMPARISON_FUNCS["="]: if cmp_value is None, return true (the tag is present).

  *Release 20210306*:
  * ExtendedNamespace,TagSetNamespace: move the .[:alpha:]* attribute support from ExtendedNamespace to TagSetNamespace because it requires Tags.
  * TagSetNamespace.__getattr__: new _i, _s, _f suffixes to return int, str or float tag values (or None); fold _lc in with these.
  * Pull most of `TaggedEntity` out into `TaggedEntityMixin` for reuse by domain specific tagged entities.
  * TaggedEntity: new .set and .discard methods.
  * TaggedEntity: new as_editable_line, from_editable_line, edit and edit_entities methods to support editing entities using a text editor.
  * ontologies: type entries are now prefixed with "type." and metadata entries are prefixed with "meta."; provide a worked ontology example in the introduction and improve related docstrings.
  * TagsOntology: new .types(), .types_names(), .meta(type_name,value), .meta_names() methods.
  * TagsOntology.__getitem__: create missing TagSets on demand.
  * New TagsOntologyCommand, initially with a "type [type_name [{edit|list}]]" subcommand, ready for use as the cmd_ont subcommand of other tag related commands.
  * TagSet: support initialisation like a dict including keywords, and move the `ontology` parameter to `_onotology`.
  * TagSet: include AttrableMappingMixin to enable attribute access to values when there is no conflict with normal methods.
  * UUID encode/decode support.
  * Honour $TAGSET_EDITOR or $EDITOR as preferred interactive editor for tags.
  * New TagSet.subtags(prefix) to extract a subset of the tags.
  * TagsOntology.value_metadata: new optional convert parameter to override the default "convert human friendly name" algorithm, particularly to pass convert=str to things which are already the basic id.
  * Rename TaggedEntity to TagSet.
  * Rename TaggedEntities to TagSets.
  * TagSet: new csvrow and from_csvrow methods imported from obsolete TaggedEntityMixin class.
  * Move BaseTagFile from cs.fstags to TagFile in cs.tagset.
  * TagSet: support access to the tag "c.x" via attributes provided there is no "c" tag in the way.
  * TagSet.unixtime: implement the autoset-to-now semantics.
  * New as_timestamp(): convert date, datetime, int or float to a UNIX timestamp.
  * Assorted docstring updates and bugfixes.

  *Release 20200716*:
  * Update for changed cs.obj.SingletonMixin API.
  * Pull in TaggedEntity from cs.sqltags and add the .csvrow property and the .from_csvrow factory.

  *Release 20200521.1*:
  Fix DISTINFO.install_requires, drop debug import.

  *Release 20200521*:
  * New ValueDetail and KeyValueDetail classes for returning ontology information; TagInfo.detail now returns a ValueDetail for scalar types, a list of ValueDetails for sequence types and a list of KeyValueDetails for mapping types; drop various TagInfo mapping/iterable style methods, too confusing to use.
  * Plumb ontology parameter throughout, always optional.
  * Drop TypedTag, Tags now use ontologies for this.
  * New TagsCommandMixin to support BaseCommands which manipulate Tags.
  * Many improvements and bugfixes.

  *Release 20200318*:
  * *Note that the TagsOntology stuff is in flux and totally alpha.*
  * Tag.prefix_name factory returning a new tag if prefix is not empty, ptherwise self.
  * TagSet.update: accept an optional prefix for inserting "foreign" tags with a distinguishing name prefix.
  * Tag.as_json: turn sets and tuples into lists for encoding.
  * Backport for Python < 3.7 (no fromisoformat functions).
  * TagSet: drop unused and illplaced .titleify, .episode_title and .title methods.
  * TagSet: remove "defaults", unused.
  * Make TagSet a direct subclass of dict, adjust uses of .update etc.
  * New ExtendedNamespace class which is a SimpleNamespace with some inferred attributes and a partial mapping API (keys and __getitem__).
  * New TagSet.ns() returning the Tags as an ExtendedNamespace, which doubles as a mapping for str.format_map; TagSet.format_kwargs is now an alias for this.
  * New Tag.from_string factory to parse a str into a Tag.
  * New TagsOntology and TypedTag classes to provide type and value-detail information; very very alpha and subject to change.

  *Release 20200229.1*:
  Initial release: pull TagSet, Tag, TagChoice from cs.fstags for independent use.


pkgId: 39e496394ddd0cb6cd841aec1290260564cc46ac0e5901221da9a0016c4ecbc2
name: python-cs.x
arch: src
version: 20240630
epoch: 0
release: 1
summary: X(), for low level debugging.
url: https://pypi.org/project/cs.x/
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cs.x-20240630-1.src.rpm
checksum_type: sha256
description:
  X(), for low level debugging.

  *Latest release 20240630*:
  X(msg,*args): handle mismatched message and format arguments.

  X() is my function for low level ad hoc debug messages.
  It takes a message and optional format arguments for use with `%`.
  It is presented here in its own module for reuse:

      from cs.x import X
      ...
      X("foo: x=%s, a=%r", x, a)

  It normally writes directly to `sys.stderr` but accepts an optional
  keyword argument `file` to specify a different filelike object.

  The following globals further tune its behaviour,
  absent the `file=` parameter:
  * `X_default_colour`: if set, messages will be ANSI coloured using
    `cs.ansi_colour.colourise`
  * `X_discard`: if true then discard the message.
    Otherwise write the message to `sys.stderr`.
    `X_discard`'s default value is `not sys.stderr.isatty()`.
  * `X_logger`: if not `None` then log a warning to that logger.
  * `X_via_tty`: if true then a pathname to which to append messages.

  The following environment variables affect the initial values of the globals:
  * `$CS_X_COLOUR`: this sets `X_default_colour`.
  * `$CS_X_LOGGER`:
    if present, an empty value sets `X_logger` to the root logger
    and a nonempty value names a logger.
  * `$CS_X_VIA_TTY`: if missing or empty, `X_via_tty` will be false.
    Otherwise,
    if `$CS_X_VIA_TTY` has a nonempty value which is a full path
    to an existing filesystem object (typically a tty)
    then is will be used for `X_via_tty`,
    otherwise `X_via_tty` will be set to `'/dev/tty'`.
    This is handy for getting debugging out of test suites,
    which often divert `sys.stderr`.



  Unconditionally write the message `msg`.

  If there are positional arguments after `msg`,
  format `msg` using  with those arguments.

  Keyword arguments:
  * `file`: optional keyword argument specifying the output file.
  * `colour`: optional text colour.
    If specified, surround the message with ANSI escape sequences
    to render the text in that colour.

  If `file` is not `None`, write to it unconditionally.
  Otherwise, the following globals are consulted in order:
  * `X_logger`: if not `None` then log a warning to that logger
  * `X_via_tty`: if true then append the message to the path it contains
  * `X_discard`: if true then discard the message
  Otherwise write the message to `sys.stderr`.

  `X_logger` is `None` by default.
  `X_via_tty` is initialised from the environment variable `$CS_X_VIA_TTY`.
  `X_discard` is true unless `sys.stderr.isatty()` is true.



  Wrapper for `X()` rendering in yellow.





  *Release 20240630*:
  X(msg,*args): handle mismatched message and format arguments.

  *Release 20240316*:
  Fixed release upload artifacts.

  *Release 20240201*:
  Doc updates.

  *Release 20231129*:
  New $CS_X_LOGGER environment variable to direct messages to a logger.

  *Release 20230331*:
  Move the open-tty-for-append hacks into cs.gimmicks.open_append, fix unclosed file handle.

  *Release 20230218*:
  Accomodate idiotic Linux /dev/tty open semantics.

  *Release 20221118*:
  Tweak for open of /dev/tty, still not properly resolved.

  *Release 20220918*:
  * Drop Xtty(), obsolete.
  * X(): special handling for unseeking output files - I've had a Linux system moan about opening /dev/tty for append.

  *Release 20211208*:
  X_via_tty: now accept full path to a tty in $CS_X_VIA_TTY to aid messaging to other terminals.

  *Release 20210123*:
  X: honour new $CS_X_COLOUR environment variable setting the default colour, default uncoloured.

  *Release 20201227*:
  New Y() which calls X(...,colour=yellow) - I now often go `from cs.x import Y as X`.

  *Release 20201102*:
  * Set X_via_tty if $CS_X_VIA_TTY.
  * Put X() into builtins if $CS_X_BUILTIN.

  *Release 20181231*:
  * X: trivial ANSI colour support via new `colour` keyword argument.
  * New global X_discard, False unless sys.stderr.isatty.

  *Release 20180726*:
  doco improvements

  *Release 20170902*:
  Move X() into its own module, used for ad hoc debugging everywhere.

  *Release 20170707.3*:
  tweak DISTINFO

  *Release 20170707.2*:
  Doc tweak.

  *Release 20170707.1*:
  Added README.

  *Release 20170707*:
  Separate X() out into new module cs.x for cheap import.


pkgId: dae3ce0da9a8df4850357053e2d2003325646ee72f90e2525cd9ba2745bffd78
name: python-cs2-battle-bot-api-client
arch: src
version: 0.0.35
epoch: 0
release: 1
summary: A client library for accessing cs2-battle-bot-api
url: https://pypi.org/project/cs2-battle-bot-api-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cs2-battle-bot-api-client-0.0.35-1.src.rpm
checksum_type: sha256
description:
  [![Python package](https://github.com/Qwizi/cs2-battle-bot-api-client/actions/workflows/publish.yml/badge.svg)](https://github.com/Qwizi/cs2-battle-bot-api-client/actions/workflows/publish.yml)
  [![Generate Client](https://github.com/Qwizi/cs2-battle-bot-api-client/actions/workflows/generate_client.yml/badge.svg)](https://github.com/Qwizi/cs2-battle-bot-api-client/actions/workflows/generate_client.yml)



  A client library for accessing cs2-battle-bot-api



  First, create a client:

  ```python
  from cs2_battle_bot_api_client import Client

  client = Client(base_url="https://api.example.com")
  ```

  If the endpoints you're going to hit require authentication, use `AuthenticatedClient` instead:

  ```python
  from cs2_battle_bot_api_client import AuthenticatedClient

  client = AuthenticatedClient(base_url="https://api.example.com", token="SuperSecretToken")
  ```

  Now call your endpoint and use your models:

  ```python
  from cs2_battle_bot_api_client.models import MyDataModel
  from cs2_battle_bot_api_client.api.my_tag import get_my_data_model
  from cs2_battle_bot_api_client.types import Response

  with client as client:
      my_data: MyDataModel = get_my_data_model.sync(client=client)
      
      response: Response[MyDataModel] = get_my_data_model.sync_detailed(client=client)
  ```

  Or do the same thing with an async version:

  ```python
  from cs2_battle_bot_api_client.models import MyDataModel
  from cs2_battle_bot_api_client.api.my_tag import get_my_data_model
  from cs2_battle_bot_api_client.types import Response

  async with client as client:
      my_data: MyDataModel = await get_my_data_model.asyncio(client=client)
      response: Response[MyDataModel] = await get_my_data_model.asyncio_detailed(client=client)
  ```

  By default, when you're calling an HTTPS API it will attempt to verify that SSL is working correctly. Using certificate verification is highly recommended most of the time, but sometimes you may need to authenticate to a server (especially an internal server) using a custom certificate bundle.

  ```python
  client = AuthenticatedClient(
      base_url="https://internal_api.example.com",
      token="SuperSecretToken",
      verify_ssl="/path/to/certificate_bundle.pem",
  )
  ```

  You can also disable certificate validation altogether, but beware that **this is a security risk**.

  ```python
  client = AuthenticatedClient(
      base_url="https://internal_api.example.com",
      token="SuperSecretToken",
      verify_ssl=False
  )
  ```

  Things to know:
  1. Every path/method combo becomes a Python module with four functions:
      1. `sync`: Blocking request that returns parsed data (if successful) or `None`
      1. `sync_detailed`: Blocking request that always returns a `Request`, optionally with `parsed` set if the request was successful.
      1. `asyncio`: Like `sync` but async instead of blocking
      1. `asyncio_detailed`: Like `sync_detailed` but async instead of blocking

  1. All path/query params, and bodies become method arguments.
  1. If your endpoint had any tags on it, the first tag will be used as a module name for the function (my_tag above)
  1. Any endpoint which did not have a tag will be in `cs2_battle_bot_api_client.api.default`



  There are more settings on the generated `Client` class which let you control more runtime behavior, check out the docstring on that class for more info. You can also customize the underlying `httpx.Client` or `httpx.AsyncClient` (depending on your use-case):

  ```python
  from cs2_battle_bot_api_client import Client

  def log_request(request):
      print(f"Request event hook: {request.method} {request.url} - Waiting for response")

  def log_response(response):
      request = response.request
      print(f"Response event hook: {request.method} {request.url} - Status {response.status_code}")

  client = Client(
      base_url="https://api.example.com",
      httpx_args={"event_hooks": {"request": [log_request], "response": [log_response]}},
  )


  ```

  You can even set the httpx client directly, but beware that this will override any existing settings (e.g., base_url):

  ```python
  import httpx
  from cs2_battle_bot_api_client import Client

  client = Client(
      base_url="https://api.example.com",
  )

  client.set_httpx_client(httpx.Client(base_url="https://api.example.com", proxies="http://localhost:8030"))
  ```


  This project uses [Poetry](https://python-poetry.org/) to manage dependencies  and packaging.  Here are the basics:
  1. Update the metadata in pyproject.toml (e.g. authors, version)
  1. If you're using a private repository, configure it with Poetry
      1. `poetry config repositories.<your-repository-name> <url-to-your-repository>`
      1. `poetry config http-basic.<your-repository-name> <username> <password>`
  1. Publish the client with `poetry publish --build -r <your-repository-name>` or, if for public PyPI, just `poetry publish --build`

  If you want to install this client into another project without publishing it (e.g. for development) then:
  1. If that project **is using Poetry**, you can simply do `poetry add <path-to-this-client>` from that project
  1. If that project is not using Poetry:
      1. Build a wheel with `poetry build -f wheel`
      1. Install that wheel from the other project `pip install <path-to-wheel>`


pkgId: 5302d706d69200538a533e80e77cb4dfeae94ca5dd154da9653409e97e86877e
name: python-cs2fade
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: CS2 fade utility
url: https://github.com/Helyux/cs2fade
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cs2fade-0.1.2-1.src.rpm
checksum_type: sha256
description:
  <div id="shields" align="center">

  <!-- PROJECT SHIELDS -->
  [![Contributors][contributors-shield]][contributors-url]
  [![Forks][forks-shield]][forks-url]
  [![Stargazers][stars-shield]][stars-url]
  [![Issues][issues-shield]][issues-url]
  [![MIT License][license-shield]][license-url]
  [![Xing][xing-shield]][xing-url]
  </div>



  Python port of [@chescos](https://github.com/chescos) original
  [csgo-fade-percentage-calculator](https://github.com/chescos/csgo-fade-percentage-calculator).
  Check out his repository for more information.

  If you notice any errors please feel free to open an issue or pull request.

  <!-- MARKDOWN LINKS & IMAGES -->
  <!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
  [contributors-shield]: https://img.shields.io/github/contributors/Helyux/cs2-fade-calculator-py.svg?style=for-the-badge
  [contributors-url]: https://github.com/Helyux/cs2-fade-calculator-py/graphs/contributors
  [forks-shield]: https://img.shields.io/github/forks/Helyux/cs2-fade-calculator-py.svg?style=for-the-badge
  [forks-url]: https://github.com/Helyux/cs2-fade-calculator-py/network/members
  [stars-shield]: https://img.shields.io/github/stars/Helyux/cs2-fade-calculator-py.svg?style=for-the-badge
  [stars-url]: https://github.com/Helyux/cs2-fade-calculator-py/stargazers
  [issues-shield]: https://img.shields.io/github/issues/Helyux/cs2-fade-calculator-py.svg?style=for-the-badge
  [issues-url]: https://github.com/Helyux/cs2-fade-calculator-py/issues
  [license-shield]: https://img.shields.io/github/license/Helyux/cs2-fade-calculator-py.svg?style=for-the-badge
  [license-url]: https://github.com/Helyux/cs2-fade-calculator-py/blob/master/LICENSE
  [xing-shield]: https://img.shields.io/static/v1?style=for-the-badge&message=Xing&color=006567&logo=Xing&logoColor=FFFFFF&label
  [xing-url]: https://www.xing.com/profile/Lukas_Mahler10


pkgId: f7192477ae0605105f69d7e99249bfc42af6909e7d00d0da733fc4715e8f47dd
name: python-cs2inspect
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: CS2 inspect link utility
url: https://github.com/Helyux/cs2inspect
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cs2inspect-0.2.3-1.src.rpm
checksum_type: sha256
description:
  <div id="shields" align="center">

  <!-- PROJECT SHIELDS -->
  [![Contributors][contributors-shield]][contributors-url]
  [![Forks][forks-shield]][forks-url]
  [![Stargazers][stars-shield]][stars-url]
  [![Issues][issues-shield]][issues-url]
  [![MIT License][license-shield]][license-url]
  [![Xing][xing-shield]][xing-url]
  </div>





  `cs2inspect` is a python package used for creating and working with CS2 inspect links and gen codes.



  - Creating 'unmasked' inspect links (containing the owners steam id)
  - Creating 'masked' inspect links (not containing the owners steam id)
  - Creating gen codes
  - Checking inspect link validity (using regex)

  - Structured protobuf creation
  - Hex data handling (for 'masked' inspect links)



  ```bash
  pip install cs2inspect
  ```



  ```python
  import cs2inspect


  link_data = {
      'asset_id': '38350177019',
      'class_id': '9385506221951591925',
      'owner_id': '76561198066322090'
  }
  link_str = cs2inspect.link(link_data)
  print(link_str)  # = steam://rungame/730/76561202255233023/+csgo_econ_action_preview%20S76561198066322090A38350177019D9385506221951591925


  proto_base = cs2inspect.Builder(
      defindex=7,
      paintindex=941,
      paintseed=2,
      paintwear=0.22540508210659027,
      rarity=5,
  )


  proto_base.stickers.append({'slot': 2, 'sticker_id': 7203, 'wear': 0})

  try:
      
      protobuf = proto_base.build()
  except Exception as e:
      print(f"Build failed: {e}")
      exit(1)

  link_str = cs2inspect.link(protobuf)
  print(link_str)  # = steam://rungame/730/76561202255233023/+csgo_econ_action_preview%2000180720AD0728053897A19BF3034002620A080210A3381D000000006B570344


  gen_str = cs2inspect.gen(protobuf, prefix="!g")  # You can omit prefix to get '!gen'
  print(gen_str)   # = !g 7 941 2 0.22540508210659027 7203 0.0

  ```


  Contributions are welcome! Open an issue or submit a pull request.


  GPLv3 License. See the LICENSE file for details.

  <!-- MARKDOWN LINKS & IMAGES -->
  <!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
  [contributors-shield]: https://img.shields.io/github/contributors/Helyux/cs2inspect.svg?style=for-the-badge
  [contributors-url]: https://github.com/Helyux/cs2inspect/graphs/contributors
  [forks-shield]: https://img.shields.io/github/forks/Helyux/cs2inspect.svg?style=for-the-badge
  [forks-url]: https://github.com/Helyux/cs2inspect/network/members
  [stars-shield]: https://img.shields.io/github/stars/Helyux/cs2inspect.svg?style=for-the-badge
  [stars-url]: https://github.com/Helyux/cs2inspect/stargazers
  [issues-shield]: https://img.shields.io/github/issues/Helyux/cs2inspect.svg?style=for-the-badge
  [issues-url]: https://github.com/Helyux/cs2inspect/issues
  [license-shield]: https://img.shields.io/github/license/Helyux/cs2inspect.svg?style=for-the-badge
  [license-url]: https://github.com/Helyux/cs2inspect/blob/master/LICENSE
  [xing-shield]: https://img.shields.io/static/v1?style=for-the-badge&message=Xing&color=006567&logo=Xing&logoColor=FFFFFF&label
  [xing-url]: https://www.xing.com/profile/Lukas_Mahler10


pkgId: 5dcbe4e24f1c083481b05b2d18af91c868d3e313725d7ac827fb0dcdb36d4311
name: python-cs2pattern
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: CS2 pattern utility
url: https://github.com/Helyux/cs2pattern
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cs2pattern-0.0.1-1.src.rpm
checksum_type: sha256
description:
  <div id="shields" align="center">

  <!-- PROJECT SHIELDS -->
  [![Contributors][contributors-shield]][contributors-url]
  [![Forks][forks-shield]][forks-url]
  [![Stargazers][stars-shield]][stars-url]
  [![Issues][issues-shield]][issues-url]
  [![MIT License][license-shield]][license-url]
  [![Xing][xing-shield]][xing-url]
  </div>





  `cs2pattern` is a python package used for working with cs2 paint seeds, aka pattern.



  ```bash
  pip install cs2pattern
  ```


  Contributions are welcome! Open an issue or submit a pull request.


  GPLv3 License. See the LICENSE file for details.

  <!-- MARKDOWN LINKS & IMAGES -->
  <!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
  [contributors-shield]: https://img.shields.io/github/contributors/Helyux/cs2pattern.svg?style=for-the-badge
  [contributors-url]: https://github.com/Helyux/cs2pattern/graphs/contributors
  [forks-shield]: https://img.shields.io/github/forks/Helyux/cs2pattern.svg?style=for-the-badge
  [forks-url]: https://github.com/Helyux/cs2pattern/network/members
  [stars-shield]: https://img.shields.io/github/stars/Helyux/cs2pattern.svg?style=for-the-badge
  [stars-url]: https://github.com/Helyux/cs2pattern/stargazers
  [issues-shield]: https://img.shields.io/github/issues/Helyux/cs2pattern.svg?style=for-the-badge
  [issues-url]: https://github.com/Helyux/cs2pattern/issues
  [license-shield]: https://img.shields.io/github/license/Helyux/cs2pattern.svg?style=for-the-badge
  [license-url]: https://github.com/Helyux/cs2pattern/blob/master/LICENSE
  [xing-shield]: https://img.shields.io/static/v1?style=for-the-badge&message=Xing&color=006567&logo=Xing&logoColor=FFFFFF&label
  [xing-url]: https://www.xing.com/profile/Lukas_Mahler10


pkgId: e08ede59b9767fa96a950dc5906be111398635a36a8ec9e785944ea1d8347390
name: python-cs2solutions
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: A package containing solutions for the CS2 lecture at ETH Zürich
url: https://idsc.ethz.ch/education/lectures/control-systems-ii.html
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cs2solutions-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Python solution and helper package for the Control Systems II Jupyter Notebooks at ETHz.
  Exercise Notebooks can be found on: https://github.com/idsc-frazzoli/CS2-2024-notebooks


  The cs2solutions package can be installed directly using '%pip install cs2solutions' in the Jupyter notebook or 'pip install cs2solutions' in the terminal.

  ```bash
  pip install cs2solutions
  ```

  Manual installation guide, such as for code contributions, can be found in the [update guide](UPDATE.md).


  Contains:
  - Utility functions for control systems, such as plotting and generic formulas
  - Solutions for all notebooks
  - Unit tests to check student implementations of code

rpm_license:
[cell repeats an earlier one in this file: 34486 characters]


pkgId: 5f2b74bce91b06cf7591960d85c303f90bb7025dba6e855200325401a804df51
name: python-cs2tc
arch: src
version: 0.1.1
epoch: 0
release: 1
url: https://github.com/hdoupe/cs2tc
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cs2tc-0.1.1-1.src.rpm
checksum_type: sha256
summary:
  Helper functions for converting Compute Studio parameters to a format compatible with Tax-Calculator.

description:
  Helper functions for converting Compute Studio parameters to a format compatible with Tax-Calculator.

  ```
  pip install -U cs2tc
  ```

  ```python
  import cs2tc

  adj = {
      "STD": [
          {"MARS": "single", "year": 2019, "value": 10},
          {"MARS": "mjoint", "year": 2019, "value": 1},
          {"MARS": "mjoint", "year": 2022, "value": 10}
      ],
      "STD_checkbox": [{"value": False}]
  }

  cs2tc.convert_policy_adjustment(adj)






  ```


pkgId: 59fc2113dc4063ab902de2ac6170456605ef7602a9bca784a0c5a282d130ab6e
name: python-cs3560-grading-lib
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A common library for the grading scripts.
url: https://pypi.org/project/cs3560-grading-lib/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cs3560-grading-lib-0.1.1-1.src.rpm
checksum_type: sha256
description:
  A common library for the grading scripts.



  ```console
  python -m pip install cs3560-grading-lib
  ```



  - Base class for a test case.
  - Utilities functions to grade make related problems.



  View the [latest documentation](https://grading-lib.readthedocs.io/en/latest/) or the documentation for the [stable version](https://grading-lib.readthedocs.io/en/stable/).



  If you are looking for a more mature projects, please see

  - [OK](https://okpy.org/) which is used in [CS 61A](https://cs61a.org/) at University of California, Berkeley. It implements the concept of
    "test case unlocking" that promotes "multi-stage problem solving process." [paper](http://denero.org/content/pubs/las15_basu_unlocking.pdf).
  - [check50](https://cs50.readthedocs.io/projects/check50/en/latest/) which is used in [CS 50](https://cs50.harvard.edu/x/2024/) at Harvard University. There are also [various other command line tools](https://cs50.readthedocs.io/).
  - Cafe Grader's [judge-script](https://github.com/cafe-grader-team/cafe-grader-judge-scripts) and its [web UI](https://github.com/cafe-grader-team/cafe-grader-web) which is (was?; well at least in 2010-ish) used by Department of Computer Engineering at Kasetsart University, Thailand.

  This library is somewhat inspired by Cafe Grader Suite and OK.

rpm_license:
  MIT License  Copyright (c) 2024 OU-CS3560  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 9277c5bc7e1148df22765accbef483ccc608d7d81e472c4d836d3b284c9d3e1b
name: python-cs3560cli
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: A set of internal tools for Ohio University's CS3560 course.
url: https://github.com/OU-CS3560/cs3560cli
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cs3560cli-0.4.0-1.src.rpm
checksum_type: sha256
description:
  A set of internal tools for [Ohio University](https://www.ohio.edu/)'s CS3560 course.



  ```console
  python -m pip install cs3560cli
  ```



  - `categorize` : Group students submitted files and put them in a folder. One folder for each student.
  - `create gh-invite` : Invite students to a team in GitHub organization using data from Canvas.
  - `create gitignore` : Create an opinionated `.gitignore` file where `macOS.gitignore` and `Windows.gitignore` are included by default.
  - `watch` : Watch for (and extract) the zip file.
  - `highlight` : Create HTML fragments of a syntax highlighted snippet of code that can then be embedded in LMS. For an image of the source code, you may want to use [Charm's freeze](https://github.com/charmbracelet/freeze) instead.
  - `check github-username` : Check if the GitHub or Codewars username the student provided actually exist or not.



  <details>
  <summary>categorize</summary>

  ![categorize movie](./tapes/categorize.gif)

  </details>

  <details>
  <summary>highlight</summary>

  ![highlight movie](./tapes/highlight.gif)

  </details>





  1. Obtain the list of enrolled students.
  2. Creating a team in GitHub organization.
  3. Add `OU-CS3560/examples` to the team.
  3. Invite all students into the team in GitHUb organization.

  Requirements

  ```ps1
  gh extension install mislav/gh-repo-collab
  ```

  ```ps1
  $TeamName = "entire-class-24f"
  gh api \
    --method POST \
    -H "Accept: application/vnd.github+json" \
    -H "X-GitHub-Api-Version: 2022-11-28" \
    /orgs/OU-CS3560/teams \
    -f name="$TeamName" \
    -f notification_setting='notifications_disabled' \
    -f privacy='closed'
  gh repo-collab add OU-CS3560/examples "OU-CS3560/$TeamName" --permission read
  python -m cs3560cli github bulk-invite
  ```



  1. (manual) Obtain team information (internal-id, members).
  2. Create a team.
  3. Create a repository.
  4. Add team to the repository with `maintain` permission.
  4. (manual) Invite students to the team.

  Requirements

  ```ps1
  gh extension install mislav/gh-repo-collab
  ```

  ```ps1
  $TeamId = ""
  $TeamHandle = "OU-CS3560/" + $TeamId
  $RepoHandle = "OU-CS3560/" + $TeamId

  $ParentTeamId = python -m cs3560cli github get-team-id OU-CS3560 entire-class-24f | Out-String
  gh api \
    --method POST \
    -H "Accept: application/vnd.github+json" \
    -H "X-GitHub-Api-Version: 2022-11-28" \
    /orgs/OU-CS3560/teams \
    -f parent_team_id=$ParentTeamId \
    -f name="$TeamId" \
    -f notification_setting='notifications_disabled' \
    -f privacy='closed'
  gh repo create --private --template OU-CS3560/team-template $RepoHandle
  gh repo-collab add $RepoHandle $TeamHandle --permission maintain
  ```

rpm_license:
  MIT License  Copyright (c) 2023 OU-CS3560  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: adff9f64f8ac20c392015dfefd6836a19a53dff4c593b4701b713dd29ad803e6
name: python-cs3apis
arch: src
version: 0.2.20240828.12222828
epoch: 0
release: 1
summary: CS3 API bindings for Python
url: https://github.com/cs3org/python-cs3apis
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cs3apis-0.2.20240828.12222828-1.src.rpm
checksum_type: sha256
description:
  [![Join the conversation](https://badges.gitter.im/cs3org/CS3APIS.svg)](https://gitter.im/cs3org/CS3APIS) [![Latest Version](https://img.shields.io/pypi/v/cs3apis)](https://pypi.org/project/cs3apis/) [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

  API definitions can be found at https://github.com/cs3org/cs3apis



  ```bash
  pip install cs3apis
  ```


pkgId: 649377a6d3fdff12c80636c5c0032b949806dbcc9f1d6421629540a7358ec329
name: python-csaf-lint
arch: src
version: 2022.7.17
epoch: 0
release: 1
summary: Experimental CSAF validator for envelope and body profiles.
url: https://github.com/sthagen/csaf-lint
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csaf-lint-2022.7.17-1.src.rpm
checksum_type: sha256
description:
  Experimental CSAF envelope and body profile validator.

  [License: MIT](https://github.com/sthagen/csaf-lint/blob/default/LICENSE)

  [![version](https://img.shields.io/pypi/v/csaf-lint.svg?style=flat)](https://pypi.python.org/pypi/csaf-lint/)
  [![downloads](https://img.shields.io/pypi/dm/csaf-lint.svg?style=flat)](https://pypi.python.org/pypi/csaf-lint/)
  [![wheel](https://img.shields.io/pypi/wheel/csaf-lint.svg?style=flat)](https://pypi.python.org/pypi/csaf-lint/)
  [![supported-versions](https://img.shields.io/pypi/pyversions/csaf-lint.svg?style=flat)](https://pypi.python.org/pypi/csaf-lint/)
  [![supported-implementations](https://img.shields.io/pypi/implementation/csaf-lint.svg?style=flat)](https://pypi.python.org/pypi/csaf-lint/)

  In short: The current version of the `csaf-lint` validates documents in various
  Common Security Advisory Framework (CSAF) formats against built-in
  or user custom schema files.

  The supported  versions are:

  * CSAF 2.0 (default is now the 2021.03.23 editor version)
  * CSAF 1.2 (aka CVRF 1.2)
  * CSAF 1.1 (aka CVRF 1.1)



  1. Expect changes to the CSAF v2.0 support because the underlying OASIS specification
  is undergoing development by the members of the OASIS technical committee.
     This may lead to breaking changes until the standard is published on
  committee specification level.
     The current supported draft JSON Schema versions are from 2021-03-23, 2021-03-19, and 2021-03-07.
  2. The previous versions namely CVRF 1.1 and 1.2 were in XML format.
  3. The current version CSAF 2.0-candidates are in JSON Schema format.

  Available on [PyPI as csaf-lint](https://pypi.org/project/csaf-lint/)



  Recommended installation of current experimental package:

  ```console
  ❯ python -m pipx install csaf-lint
  ```


  Experimental.

  **Note**: The default branch is `default`.


pkgId: ae6b845532a6e1c2a52ff03082a6781519a1bd227fea5195e027d3cd8e1b512d
name: python-csaps
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Cubic spline approximation (smoothing)
url: https://github.com/espdev/csaps
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csaps-1.2.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/espdev/csaps"><img src="https://user-images.githubusercontent.com/1299189/76571441-8d97e400-64c8-11ea-8c05-58850f8311a1.png" alt="csaps" width="400" /></a><br>
  </p>

  <p align="center">
    <a href="https://pypi.python.org/pypi/csaps"><img src="https://img.shields.io/pypi/v/csaps.svg" alt="PyPI version" /></a>
    <a href="https://pypi.python.org/pypi/csaps"><img src="https://img.shields.io/pypi/pyversions/csaps.svg" alt="Supported Python versions" /></a>
    <a href="https://github.com/espdev/csaps"><img src="https://github.com/espdev/csaps/workflows/main/badge.svg" alt="GitHub Actions (Tests)" /></a>
    <a href="https://csaps.readthedocs.io/en/latest/?badge=latest"><img src="https://readthedocs.org/projects/csaps/badge/?version=latest" alt="Documentation Status" /></a>
    <a href="https://coveralls.io/github/espdev/csaps?branch=master"><img src="https://coveralls.io/repos/github/espdev/csaps/badge.svg?branch=master" alt="Coverage Status" /></a>
    <a href="https://choosealicense.com/licenses/mit/"><img src="https://img.shields.io/pypi/l/csaps.svg" alt="License" /></a>
  </p>

  **csaps** is a Python package for univariate, multivariate and n-dimensional grid data approximation using cubic smoothing splines.
  The package can be useful in practical engineering tasks for data approximation and smoothing.



  Use pip for installing:

  ```
  pip install -U csaps
  ```

  The module depends only on NumPy and SciPy. Python 3.9 or above is supported.



  Here is a couple of examples of smoothing data.

  An univariate data smoothing:

  ```python
  import numpy as np
  import matplotlib.pyplot as plt

  from csaps import csaps

  np.random.seed(1234)

  x = np.linspace(-5., 5., 25)
  y = np.exp(-(x/2.5)**2) + (np.random.rand(25) - 0.2) * 0.3
  xs = np.linspace(x[0], x[-1], 150)

  ys = csaps(x, y, xs, smooth=0.85)

  plt.plot(x, y, 'o', xs, ys, '-')
  plt.show()
  ```

  <p align="center">
    <img src="https://user-images.githubusercontent.com/1299189/72231304-cd774380-35cb-11ea-821d-d5662cc1eedf.png" alt="univariate" />
  <p/>

  A surface data smoothing:

  ```python
  import numpy as np
  import matplotlib.pyplot as plt
  from mpl_toolkits.mplot3d import Axes3D

  from csaps import csaps

  np.random.seed(1234)
  xdata = [np.linspace(-3, 3, 41), np.linspace(-3.5, 3.5, 31)]
  i, j = np.meshgrid(*xdata, indexing='ij')
  ydata = (3 * (1 - j)**2. * np.exp(-(j**2) - (i + 1)**2)
           - 10 * (j / 5 - j**3 - i**5) * np.exp(-j**2 - i**2)
           - 1 / 3 * np.exp(-(j + 1)**2 - i**2))
  ydata = ydata + (np.random.randn(*ydata.shape) * 0.75)

  ydata_s = csaps(xdata, ydata, xdata, smooth=0.988)

  fig = plt.figure(figsize=(7, 4.5))
  ax = fig.add_subplot(111, projection='3d')
  ax.set_facecolor('none')
  c = [s['color'] for s in plt.rcParams['axes.prop_cycle']]
  ax.plot_wireframe(j, i, ydata, linewidths=0.5, color=c[0], alpha=0.5)
  ax.scatter(j, i, ydata, s=10, c=c[0], alpha=0.5)
  ax.plot_surface(j, i, ydata_s, color=c[1], linewidth=0, alpha=1.0)
  ax.view_init(elev=9., azim=290)

  plt.show()
  ```

  <p align="center">
    <img src="https://user-images.githubusercontent.com/1299189/72231252-7a9d8c00-35cb-11ea-8890-487b8a7dbd1d.png" alt="surface" />
  <p/>



  More examples of usage and the full documentation can be found at https://csaps.readthedocs.io.



  We use pytest for testing.

  ```
  cd /path/to/csaps/project/directory
  pip install -e .[tests]
  pytest
  ```



  **csaps** Python package is inspired by MATLAB [CSAPS](https://www.mathworks.com/help/curvefit/csaps.html) function that is an implementation of
  Fortran routine SMOOTH from [PGS](http://pages.cs.wisc.edu/~deboor/pgs/) (originally written by Carl de Boor).

  Also the algothithm implementation in other languages:

  * [csaps-rs](https://github.com/espdev/csaps-rs) Rust ndarray/sprs based implementation
  * [csaps-cpp](https://github.com/espdev/csaps-cpp) C++11 Eigen based implementation (incomplete)




  C. de Boor, A Practical Guide to Splines, Springer-Verlag, 1978.



  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: 403d2ef753613869ed788251e1e0f3d1b6b2c5e2b9212ba00a3034fb22731e45
name: python-csb43
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://pypi.org/project/csb43/
rpm_license: LGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csb43-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  Parsing and validation utilites for the Spanish standard norm 43 by the 'Consejo Superior Bancario' (CSB) / 'Asociación Española de Banca' (AEB) for storing bank account transactions | [es] Herramientas para leer y validar datos almacenados siguiendo la norma 43 del Consejo Superior Bancario (CSB) / Asociación Española de Banca (CSB).

description:
  <!--
  SPDX-FileCopyrightText: 2024 wmj <wmj.py@gmx.com>

  SPDX-License-Identifier: LGPL-3.0-or-later
  -->



  [![docs latest](https://readthedocs.org/projects/csb43/badge/?version=latest)](https://csb43.readthedocs.io/projects/latest/?badge=latest)

  Tools for converting from the Spanish banks' format **CSB norm 43** (*CSB43*).




  Convert a **CSB/AEB norm 43** file to other file formats.

  Supported formats:

  - OFX v1.0.3 (SGML) & v2.1.2 (XML)
  - [HomeBank CSV](http://homebank.free.fr/help/06csvformat.html)
  - *JSON*
  - *YAML*

  Additional formats are optionally provided by `tablib`:

  - *HTML*
  - *ODS*: OpenDocument spreadsheet
  - *CSV*, *TSV*: comma- or tab- separated values
  - *XLS*: Microsoft Excel spreadsheet
  - *XLSX*: OOXML spreadsheet

  For an exhaustive list, see package `tablib`.




      usage: csb2format [-h] [-v] [-s] [--no-sepa] [-df] [-d DECIMAL] [-e ENCODING] [--use-float] [-V]
                      [-f {csv,dbf,homebank,html,jira,json,latex,ods,ofx,ofx1,rst,tsv,xls,xlsx,yaml}] [-E OUTPUT_ENCODING]
                      csb_file converted_file

      Convert a CSB43 file to another format

      options:
      -h, --help            show this help message and exit
      -v, --version         show program's version number and exit

      csb43 arguments:
      csb_file              a csb43 file ('-' for stdin)
      -s, --strict          strict mode (default: False)
      --no-sepa             do not convert items to SEPA transfers or direct debits (default: True)
      -df, --dayfirst       use DDMMYY as date format while parsing the csb43 file instead of YYMMDD (default: True)
      -d DECIMAL, --decimal DECIMAL
                              set the number of decimal places for the money amount type (default: 2)
      -e ENCODING, --encoding ENCODING
                              set the input encoding ('cp850' for standard AEB file) (default: latin1)
      --use-float           export monetary amounts using binary floating point numbers as a fallback (default: str)
      -V, --verbose         show csb43 warnings (default: True)

      output arguments:
      converted_file        destination file ('-' for stdout)
      -f {csv,dbf,homebank,html,jira,json,latex,ods,ofx,ofx1,rst,tsv,xls,xlsx,yaml}, --format {csv,dbf,homebank,html,jira,json,latex,ods,ofx,ofx1,rst,tsv,xls,xlsx,yaml}
                              format of the output file (default: ofx)
      -E OUTPUT_ENCODING, --output-encoding OUTPUT_ENCODING
                              set the output encoding (default: utf-8)




  - Converting to OFX format:

          $ csb2format transactions.csb transactions.ofx

          $ csb2format --format ofx transactions.csb transactions.ofx

      or

          $ csb2format transactions.csb - > transactions.ofx

      From another app to file

          $ get_my_CSB_transactions | csb2format - transactions.ofx

  - Converting to XLSX spreadsheet format:

          $ csb2format --format xlsx transactions.csb transactions.xlsx

  - Using cp850 as the input encoding:

          $ csb2format --encoding cp850 --format xlsx transactions.csb transactions.xlsx





  *ODS*, *XLS* and *XLSX* files are generated as books, with the first sheet
  containing the accounts information, and the subsequent sheets
  containing the transactions of each one of the accounts.




  Parse a *CSB43* file and print the equivalent *OFX* file


  ```python

  from csb43.ofx import converter as ofx_converter
  from csb43.aeb43 import read_batch

  with open("movimientos.csb", "rb") as fd:
      batch = read_batch(fd)


  print(ofx_converter.convert_from_aeb43(batch))
  ```

  Parse a *CSB43* file and print the equivalent in a tabular or
  dictionary-like file format


  ```python
  from csb43 import read_batch, formats

  with open("movimientos.csb", "rb") as fd:
      batch = read_batch(fd)


  o = formats.convert_from_aeb43(batch, 'yaml')
  print(o.yaml)


  o = formats.convert_from_aeb43(batch, 'xlsx')
  with open("movimientos.xlsx", "wb") as f:
      f.write(o.xlsx)
  ```

  Build an AEB43 with a custom context:

  ```python
  import dataclasses
  from csb43 import read_batch, get_current_context


  ctx = dataclasses.replace(get_current_context(), strict=True)
  with open("movimientos.csb", "rb") as fd:
      batch = read_batch(fd, context=context)


  with get_current_context().scoped(strict=True):
      with open("movimientos.csb", "rb") as fd:
          batch = read_batch(fd)
  ```
  <!--
  SPDX-FileCopyrightText: 2024 wmj <wmj.py@gmx.com>

  SPDX-License-Identifier: LGPL-3.0-or-later
  -->



  Basic functionality (conversion to json, homebank and OFX)

      $ pip install csb43


  Conversion to YAML

      $ pip install csb43[yaml]


  Conversion to basic Tablib formats

      $ pip install csb43[basic_formats]


  Conversion to all Tablib formats

      $ pip install csb43[formats]

  Conversion to all supported formats

      $ pip install csb43[all]



  <!--
  SPDX-FileCopyrightText: 2024 wmj <wmj.py@gmx.com>

  SPDX-License-Identifier: LGPL-3.0-or-later
  -->





  - Removed code marked as deprecated in version 0.10.0.
  - Fall back to numerical currency code if no letter_3 code is found by pycountry.
  - Add table of historical ISO-4217 currency codes, needed to support Spanish records that have not been converted from Peseta to Euro.
  - Fix: arguments passed to a record constructor were not applied to the bytes representation.
  - Fail or warn if a floating-point number cannot be properly represented as a fixed-point number.



  - Allow records with different sizes due to a wrong number of spaces



  - BREAKING CHANGES!
  - Dropped support for python < 3.8. If you need support for old versions, please do not upgrade.
  - New subpackage `csb43.aeb43`: CSB43 reimplemented using field descriptors:
      - the original binary record is kept as the internal representation
      - consistent behaviour for field types (money, currency, int, string, etc...)
      - validation failures will raise ValidationException o ValidationWarning depending of their gravity
      - parsing of SEPA transfers and SEPA direct debits information stored in optional items in transactions.
  - Subpackage `csb43.csb43` has been deprecated and it will be removed in a future version (and every package object that use it).
  - Classes and functions using camel case have been deprecated and they will be removed in a future version.
  - Moved package settings from `setup.py` to `pyproject.toml`
  - Updated dependencies.



  - Add support for Python 3.12 (thanks to Cédric Krier)



  - Fixed setuptool's deprecation warning on python==3.10 (thanks to @mb)
  - Fixed duplicated documentation of the same objects by sphinx (thanks to @mb)



  - Added python_requires >= 3.6 (thanks to Cédric Krier)



  - Dropped support for Python 2 (thanks to Sergi Almacellas)
  - Added support for Python 3.8 and 3.9 (thanks to Sergi Almacellas)
  - Added compatibility with tablib >= 1.0.0 (thanks to Sergi Almacellas)
  - Type hinting



  - Fixed tablib requirement (< 1.0.0)
  - Fixed parsing of records with code 00 (thanks to Uttam Sharma)



  - Do not fail with C locale (thanks to Cédric Krier)



  - Fixed decimal values conversion in JSON and tabular formats (thanks to Harshad Modi).
  - Fixed OFX validation (ORIGCURRENCY field).
  - An error is raised when the currency code is not found.



  - Text values are stored as string instead of bytes (thanks to Sergi Almacellas)
  - Warnings are raised using the 'warnings' module.
  - An encoding where control characters are different from ascii is not allowed. An exception will be raised.
  - csb2format: added encoding as a new parameter.



  - Defined installation targets: `yaml` and `formats` (thanks to Sergi Almacellas & Cédric Krier).
  - Updated README file (thanks to Sergi Almacellas).
  - Removed `simplejson` dependency.
  - Dates stored as `date` instead of `datetime` (thanks to Sergi Almacellas).
  - Monetary amounts are represented as `Decimal` instead to `float` in order to prevent representation and rounding issues. These fields are exported as a string by default, conversion to float is optional (thanks to Sergi Almacellas & Cédric Krier).
  - Added temprary dependency to `openpyxl < 2.5.0` to prevent issue while trying to export to xlsx.



  - Fixed usage of pycountry >= 16.10.23rc1 objects (thanks to Alex Barcelo).
  - Package refactored to simplify the structure.



  - Fixed conversion to binary formats in python 2.
  - `tablib` backend supported in python 3.
  - N43 warnings are silenced by default.



  - OFX v 1.0.3 supported.
  - OFX Tag inv401source renamed to inv401ksource.
  - Unique transaction id when generating OFX file (thanks to Julien Moutte).



  - Most Spanish N43 files will use LATIN-1 encoding not pure ASCII (thanks to Julien Moutte).
  - Regular expression to check for account name is too limited (thanks to Julien Moutte).
  - Reference1 can hold non numerical data in information mode 1 and 2 (thanks to Julien Moutte).
  - Currency data as an inmutable list.



  - Fixed deficiencies in OFX conversion (thanks to Andrea Santambrogio). Checked XML validation against OFX2_Protocol.xsd



  - Compatible with Python 3 (except "tablib" dependencies)



  - Fixed shebang header of csb2format




  - csb2format adapted to pyinstaller
  - Executable file for Windows



  - Trivial changes



  - Several bugfixes
  - Bidirectional use of objects (file -> object, object -> file)
  - Added conversion to spreadsheets, dict and tabular formats (thanks to tablib)
  - Localization to Spanish
  - Sphinx documentation



  - Initial release


pkgId: 806c58822e7529ef1e7f5f55fae271198969b47592441e9f67ae243b3d29e57a
name: python-csbdeep
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: CSBDeep - a toolbox for Content-aware Image Restoration (CARE)
url: http://csbdeep.bioimagecomputing.com/
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csbdeep-0.8.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/csbdeep.svg)](https://pypi.org/project/csbdeep)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/csbdeep/badges/version.svg)](https://anaconda.org/conda-forge/csbdeep)
  [![Test](https://github.com/CSBDeep/CSBDeep/workflows/Test/badge.svg)](https://github.com/CSBDeep/CSBDeep/actions?query=workflow%3ATest)
  [![Test (PyPI)](https://github.com/CSBDeep/CSBDeep/workflows/Test%20(PyPI)/badge.svg)](https://github.com/CSBDeep/CSBDeep/actions?query=workflow%3A%22Test+%28PyPI%29%22)



  This is the CSBDeep Python package, which provides a toolbox for content-aware restoration of fluorescence microscopy images (CARE), based on deep learning via Keras and TensorFlow.

  Please see the documentation at http://csbdeep.bioimagecomputing.com/doc/.


pkgId: b0fae72b51285e4d4b42d76a51978695a7af9b7afdb31380cae9c586c9692331
name: python-csbluegem.py
arch: src
version: 0.13.0
epoch: 0
release: 1
summary: An async wrapper for the CSBlueGem api.
url: https://github.com/fretgfr/csbluegem.py/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csbluegem.py-0.13.0-1.src.rpm
checksum_type: sha256
description:
  An asynchronous wrapper for the [CSBlueGem](https://csbluegem.com) API.



  Install from PyPI: `python3 -m pip install csbluegem.py`

  ```py
  import asyncio
  from textwrap import dedent

  import csbluegem


  async def main():
      async with csbluegem.Client() as client:
          r = await client.search(csbluegem.Item.M9Bayonet)

          for result in r.sales:
              s = f"""
                  Pattern: {result.pattern}
                  Float: {result.float}
                  Stattrak?: {result.is_stattrak}
                  Price: {result.price:,}
                  Date: {result.timestamp}
                  Origin: {result.origin}
                  Days Since Sale: {result.days_since:,}
                  """

              print(dedent(s), end="\n\n")


  if __name__ == "__main__":
      asyncio.run(main())
  ```

  Additional examples available [HERE](https://github.com/fretgfr/csbluegem.py/tree/master/examples)

  Documentation available [HERE](https://csbluegempy.readthedocs.io/en/latest/)

rpm_license:
  Copyright 2024-present fretgfr  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: ce36f0c345d3a4784c6228fb808e0fef6c64a2162e158c55c22a3a2aa4e580c1
name: python-csc-mlops
arch: src
version: 0.9.23
epoch: 0
release: 1
summary: An MLOps framework for development of clinical applications
url: https://github.com/GSTT-CSC/MLOps
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csc-mlops-0.9.23-1.src.rpm
checksum_type: sha256
description:
  <!-- PROJECT HEADING -->
  <br />
  <p align="center">
  <a href="https://github.com/GSTT-CSC/Project_template">
      <img src="assets/mlops_logo.png" alt="Logo" width="50%">
    </a>
  <p align="center">
  A continuous integration and deployment framework for healthcare AI projects
  <br />
  <a href="https://pypi.org/project/csc-mlops/"><strong>View on PyPI »</strong></a>
  <br />
  <br />
  <a href="https://github.com/GSTT-CSC/MLOps">View repo</a>
  ·
  <a href="https://github.com/GSTT-CSC/MLOps/issues">Report Bug</a>
  ·
  <a href="https://github.com/GSTT-CSC/MLOps/issues">Request Feature</a>
  </p>
  <p align="center">
    <img src="https://github.com/GSTT-CSC/MLOps/actions/workflows/master-develop-test.yml/badge.svg?branch=main">
    <img src="https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/laurencejackson/ba102d5f3e592fcd50451c2eff8a803d/raw/19cbafdaad049423cf20c725944c52a3ed3764e7/mlops_pytest-coverage-comment.json">
  </p>



  This project aims to build an effective MLOps framework for the development of AI models in a healthcare setting. The application development framework has three major components:

  The MLOps server hosts the ML lifecycle management services. An MLFlow instance serves as the management platform, providing experiment tracking and model serving.

  The [project template](https://github.com/GSTT-csc/Project_template) is the starting point for any project using this development framework. This template is flexible enough for any projects and facilitates communication with other parts of the development framework. The figure below illustrates a high level overview of the template and supporting components provided by the MLOps server.
  ![](assets/project-outline.png)


  The csc-mlops python package is available on [PyPI](https://pypi.org/project/csc-mlops) and installed by default by the [project template](https://github.com/GSTT-csc/Project_template). This package handles communication between the project and the server, performs automated tasks, and includes helper functions and classes to streamline development.

  These components work together to simplify and automate many of the processes required for controlled app development. A high level schematic of the framework is illustrated below. In this case XNAT is used as a data archive platform, the framework can be adapted to use other data stores.

  > This repository contains the source code for the server and csc-mlops components of the development framework. For further details on the project template component see the [project template repository](https://github.com/GSTT-csc/Project_template).


  This is an open source project and all contributions are welcome. Please see the [contribution guidelines](#Contributing).

  ![](assets/guiding-principles.png)





  * [MLFlow](https://mlflow.org/) Open source platform to manage the ML lifecycle
  * [MINIO](https://min.io/) High performance object storage suite
  * [NGINX](https://www.nginx.com/) Reverse proxy server

  It's not essential to have a complete understanding of all of these, but a high-level understanding of [MLFlow](https://mlflow.org/) in particular will be useful!


  <!-- GETTING STARTED  -->


  The production version of this project is intended to run on a dedicated remote machine on an isolated network. This documentation will often describe the MLOps server, development machine and runner as separate machines, but there is no reason these cannot be the same machine if the network locations point to the localhost.


  First follow the instructions to install [Docker](https://docs.docker.com/engine/install/) and [docker-compose](https://docs.docker.com/compose/install/).

  Check docker and docker-compose are working by calling passing the help argument on the command line. If the help information is not returned, or an error is given, revisit the docker installation docs.
  ```sh
  docker --help
  docker-compose --help
  ```


  1. Clone and enter the repository
     ```sh
     git clone https://github.com/GSTT-CSC/MLOps.git
     cd MLOps
     ```

  2. The server should be configured by creating an environment file at ```/mlflow_server/.env```. The environment variable shown are given as an example, and should not be used for a production deployment.

  Setting these variables is a requirement, the server will fail to start if they are undefined.

  **Please do not use shown values. Consider Writing you own usernames and passwords.**

  ```shell

  AWS_ACCESS_KEY_ID=minioUsername
  AWS_SECRET_ACCESS_KEY=minioPassword
  MLFLOW_S3_IGNORE_TLS=true
  POSTGRES_USER=use
  POSTGRES_PASSWORD=pass
  POSTGRES_DB=db
  ```

  3. Navigate to the mlflow_server directory and start the service. Any docker images that are not present on your local system will be pulled from dockerhub (which might take a while).

  ```shell
   cd mlflow_server
   docker-compose up -d --build
   ```

  4. To enable access to the minio artifact storage the host machine needs to be authenticated. Any of the methods supported by boto3 should be compatible, the recommended authentication method is to create an [aws credentials file](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html). e.g. for ubuntu/linux

  ```
  [default]
  AWS_ACCESS_KEY_ID=minioUsername
  AWS_SECRET_ACCESS_KEY=minioPassword
  ```

  Upon a successful build the server should now be up and running locally. By default, the mlflow user interface can be accessed at ```http:/localhost:85``` and minio can be accessed at ```https:/localhost:8002```.

  To check if the server is up and running successfully running ```docker ps``` in the terminal lists the running containers, and we should see something like:

  ```angular2html
  CONTAINER ID   IMAGE                                      COMMAND                  CREATED             STATUS                       PORTS                                        NAMES
  3d51a7580b6f   mlflow_nginx                               "nginx -g 'daemon of…"   About an hour ago   Up About an hour             0.0.0.0:80->80/tcp, 0.0.0.0:8002->8002/tcp   mlflow_nginx
  1baa8ff12814   mlflow_app                                 "mlflow server --bac…"   About an hour ago   Up About an hour             5000/tcp                                     mlflow_server
  a397b4149c5f   minio/minio:RELEASE.2021-03-17T02-33-02Z   "/usr/bin/docker-ent…"   About an hour ago   Up About an hour (healthy)   9000/tcp, 9002/tcp                           mlflow_server_s3_1
  65374369fe4d   postgres:13.1                              "/docker-entrypoint.…"   About an hour ago   Up About an hour (healthy)   5432/tcp,                                    mlflow_db
  ```


  When we ran ```docker-compose up``` we started 4 networked containers, each of which serves a purpose within the MLOps framework.
  1. **NGINX**: The nginx container acts as a reverse proxy to control network traffic.
  2. **MLflow**: The MLflow container hosts our MLflow server instance. This server is responsible for tracking and logging the MLOps events sent to it.
  3. **MINIO**: The MINIO container hosts our MINIO server. Here we are using MINIO as a self hosted S3 storage location. The MLflow container interfaces well with S3 storage locations for logging artifacts (models, images, plots etc)
  4. **postgres**: The database server container is visible only to the MLflow container, which logs MLflow entities to the postgres database hosted on this container. MLFlow entities should not be confused with artifacts (stored on MINIO), and are simple values such as metrics, parameters and configuration options which can be efficiently stored in a database.

  There are two [bridge networks](https://docs.docker.com/network/bridge/) which connect these containers, named 'frontend' and 'backend'. The backend is used for communication between containers and is not accessible from the host (or remote), the frontend is accesible from the host (or remote) through the NGINX reverse proxy. NGINX will act as our gatekeeper and all requests will pass through it. This enables us to take advantage of NGINX load balancing and authentication in production versions.


  MLflow is a framework for managing the full lifecycle of AI models. It contains tools to cover each stage of AI model lifecycle it contains 4 major component Tracking, Projects, Models, and a Model Registry. The endpoint for these tools is an MLflow server that cun run on local or remote hardware and handles all aspects of the lifecycle.

  Currently, we will focus primarily on the tracking and projects components.

  * Tracking refers to tools used to track experiments to record and compare parameters and results. This is done by adding logging snippets to the ML code to record things like hyper-parameters, metrics and artifacts. These entities are then associated with a particular run with a specific git commit. This git commit points to a specific version of the project files. This means that by using MLflow tracking we are able to identifiy the code used to train an AI model and make comparisons following changes to code structure and hyperparameter choices.

  * MLflow uses projects to encapsulate AI tools in a reusable and reproducible way, based primarily on conventions. It also enables us to chain together project workflows meaning we are able to automate a great deal of the model development process.




  The csc-mlops package can be installed using pip:
  ```angular2html
  pip install csc-mlops
  ```

  The `Experiment` class is the primary interface between the developers project code and the MLOps  processes. By using `Experiment` a number of important processes are automated:
  - Project configuration and registration
  - Communication with the MLOps server
  - Ensures all project code is committed and current with repository
  - Docker image built if it can't be found locally
  - Project logger configured

  To use the Experiment class the project must be run using a syntax such as:

  ```python
  from mlops.Experiment import Experiment

  config_path = 'config/config.cfg'

  exp = Experiment(config_path=config_path)
  exp.run(docker_args={}, entry_point='main')
  ```

  > When using the [project template](https://github.com/GSTT-csc/Project_template) this process is performed when executing the `run_project.py` script.

  > For more information on how to define the project configuration using a config.cfg file see the [project template](https://github.com/GSTT-csc/Project_template) documentation


  <!-- Additional tools -->

  Additional tools designed to be used with MLOps are located in the [tools](tools) folder.

  - [Data toolkit](tools/datatoolkit)
    - Tools for collecting information about large data stores.


  <!-- ROADMAP -->

  See the [open issues](https://github.com/GSTT-CSC/MLOps/issues) for a list of proposed features (and known issues).

  <!-- CONTRIBUTING -->

  1. Fork or clone the Project
  2. Since all code changes are staged on the `develop` branch before releases you will need to checkout this branch first (`git checkout -b develop`)
  3. Create your Feature Branch off of `develop` (`git checkout -b feature/AmazingFeature`)
  4. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
  5. Push to the remote (`git push origin feature/AmazingFeature`)
  6. Open a Pull Request and specify that you want to merge your feature branch into the `develop` branch


  When contributing, you are _strongly_ encouraged to write tests for any functions or classes you add. Please uses pytest and add your tests to an appropriate location in the  `tests` directory, which also contains some examples to get you started.

  <!-- Warning! -->

  Please be aware of unsafe deserialisation when utilising MLFlow, do not download models from publically hosted MLFlow instances and then load them locally as this can allow potentially malicious code to be run on your machine.

  https://github.com/advisories/GHSA-cwgg-w6mp-w9hg

  <!-- ACKNOWLEDGEMENTS -->


  * [README template by othneildrew](https://github.com/othneildrew/Best-README-Template)


  <!-- MARKDOWN LINKS & IMAGES -->
  <!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
  [contributors-shield]: https://img.shields.io/github/contributors/github_username/repo.svg?style=for-the-badge
  [contributors-url]: https://github.com/github_username/repo/graphs/contributors
  [forks-shield]: https://img.shields.io/github/forks/github_username/repo.svg?style=for-the-badge
  [forks-url]: https://github.com/github_username/repo/network/members
  [stars-shield]: https://img.shields.io/github/stars/github_username/repo.svg?style=for-the-badge
  [stars-url]: https://github.com/github_username/repo/stargazers
  [issues-shield]: https://img.shields.io/github/issues/github_username/repo.svg?style=for-the-badge
  [issues-url]: https://github.com/github_username/repo/issues
  [license-shield]: https://img.shields.io/github/license/github_username/repo.svg?style=for-the-badge
  [license-url]: https://github.com/github_username/repo/blob/master/LICENSE.txt
  [linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=for-the-badge&logo=linkedin&colorB=555
  [linkedin-url]: https://linkedin.com/in/github_username


pkgId: 4190a5f8fdf97d414c8543cdf9c14773bf1715624aea8be933fe32da769350a1
name: python-csc-recorder
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: CSC eRecording python wrapper
url: https://github.com/Lenders-Cooperative/CSCRecorder
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csc-recorder-1.4.1-1.src.rpm
checksum_type: sha256
description:
  Python wrapper for CSC Recorder.

  `pip install csc-recorder`




  ```
  from csc_recorder.CSCRecorder import CSCRecorder


  client = CSCRecorder('host', 'username', 'password')


  data, response = client.send_package('1234_TEST', '48201', 'Default Office', {'document_name': 'test', 'document_type': 'Deed'}, 'paperfulfillment', True)

  ```
  The first three params are required:
  - client_package_id
  - fips
  - assigned_office

  The dictionary in the params supports the below attributes, they're not required:
  - document_name
  - document_type
  - send_to_county
  - send_to_state
  - grantee_first_name
  - grantee_last_name
  - grantee_middle_name
  - grantee_suffix
  - grantee_title
  - grantor_first_name
  - grantor_first_name
  - grantor_last_name
  - grantor_middle_name
  - grantor_suffix
  - grantor_title
  - consideration_amount
  - original_recording_date
  - original_instrument_no
  - original_deed_book
  - original_deed_page
  - assesors_parcel_id
  - date_of_note
  - amount_of_note
  - property_street_address_1
  - property_city
  - property_state
  - property_zip
  - requesting_name
  - return_name
  - return_company
  - return_street_address_1
  - return_city
  - return_state
  - return_zip
  - requesting_company
  - requesting_address_1
  - requesting_city
  - requesting_state
  - requesting_zip
  - doc_image **(NOTE: base64 PDF's)

  The last 2 params are optional as well.
  - service_type, defaults to None, but currently you can also add 'paperfulillment'
  - no_document, defaults to False, but you can make the package send 0 document attributes by marking True


pkgId: ce6b0c2236ef834168c8f2d91250a322adebd411482fe1054492b0f61df7fe3f
name: python-cschwabpy
arch: src
version: 0.1.4.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/cschwabpy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cschwabpy-0.1.4.3-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)



  This is a Python client library for accessing the Charles Schwab stock and option trade API. It provides a convenient way to interact with the Charles Schwab trading platform programmatically.



  - [x] Authenticate with your Charles Schwab account
  - [X] Automated refreshing of access token
  - [x] Download option chain data
  - [x] Get account information
  - [x] Place stock and option trades
  - Retrieve trade history [Work in Progress]
  - Monitor real-time market data [TODO]



  To install the Charles Schwab API client, you can use pip:
  ```
  pip install CSchwabPy
  ```



  * Authentication & Get Access Token & Refresh Token

  ```python



  from cschwabpy.SchwabClient import SchwabClient

  app_client_key = "---your-app-client-key-here-"
  app_secret = "app-secret"

  schwab_client = SchwabClient(app_client_id=app_client_key, app_secret=app_secret)
  schwab_client.get_tokens_manually()


  > python cschwab.py





  ticker = '$SPX'

  expiration_list = schwab_client.get_option_expirations(underlying_symbol = ticker)


  from_date = 2024-07-01
  to_date = 2024-07-01

  opt_chain_result = schwab_client.download_option_chain(ticker, from_date, to_date)


  opt_df_pairs = opt_chain_result.to_dataframe_pairs_by_expiration()

  for df in opt_df_pairs:
      print(df.expiration)
      print(f"call dataframe size: {df.call_df.shape}. expiration: {df.expiration}")
      print(f"put dataframe size: {df.put_df.shape}. expiration: {df.expiration}")
      print(df.call_df.head(5))
      print(df.put_df.head(5))

  ```


  git tag v0.1.3.9
  git push origin tag v0.1.3.9


pkgId: 790aa011d02eba493f087f3a5ba3394ff2552e4fd4fb3cb04a6d3062ebb694da
name: python-csciutils
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: 中信建投国际自动化工作
url: https://pypi.org/project/csciutils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csciutils-1.1.1-1.src.rpm
checksum_type: sha256
description:
  本包仅限于中信建投证券股份有限公司及其下属子公司使用，为中信建投国际自动化业务民间快捷包。





  - 新增了天眼查爬虫模块，目前支持：
      - 搜索关键字
      - 企业基本工商信息表爬取（不清洗）
  - 新增了代理模块


  - bug fix


  - 修复了FetchInfo中无法使用代理的问题


  - 修复了必须指定exe path的问题


  - 加入了企业预警通模块
      - 支持登录
      - 支持抓取股东信息（直接+间接）


  - 加入了PreKYCCC模块
      - 支持了对checklist的proxy对应处理


  - 部分低版本Python不支持安装python-docx，此版本先删除相关依赖，需手动添加


  - 加入了DOCX模块
      - 支持正文、表格、脚注的保留格式替换
  - 加入了Inputs模块
      - 支持多字段和带换行字段的可视化输入
  - 加入了iFinD模块
      - 支持了access_token的获取
      - 支持了工商信息的获取
          - 统一社会信用代码
          - 经营范围
          - 成立日期
          - 注册地址
          - 联系方式
          - 法定代表人
          - 注册资本
          - 注册资本单位
          - 省份
          - 授信金额（亿）
          - 未使用授信金额（亿）
          - 已使用授信金额（亿）
          - 最新授信日期


pkgId: 5ba460976ccd8c985db8a2f2bb22befb6d6fcfe28c2b6955ae7835ac94fa1718
name: python-cscmiko
arch: src
version: 0.0.21
epoch: 0
release: 1
summary: cisco devices SDK based on netmiko
url: https://github.com/Ali-aqrabawi/cscmiko
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cscmiko-0.0.21-1.src.rpm
checksum_type: sha256
description:
  SDK for cisco Catalyst , Nexus, ASA, wireless lan controllers, built using Netmiko and ntc-templates,



     `pip install cscmiko`





  to get interfaces from the device:

      from cscmiko.devices import CatSwitch
      my_switch = CatSwitch(host='192.168.1.1', username='admin', password='admin')
      my_switch.fetch_interfaces()

      for interface in my_switch.interfaces :
          print(interface.name , " is " , interface.link_status)

  results :

      GigabitEthernet1/1/1  is  administratively down
      GigabitEthernet1/1/2  is  administratively down
      GigabitEthernet1/1/3  is  administratively down
      TenGigabitEthernet1/1/4  is  up
      TenGigabitEthernet1/1/5  is  up
      TenGigabitEthernet1/2/1  is  down
      TenGigabitEthernet1/2/2  is  up

  you can also filter:

      filtered = my_switch.filter(status = 'down')  # return list of down interfaces objects


  to add a VLAN to the device:

      from cscmiko.devices import CatSwitch
      my_switch = CatSwitch(host='192.168.1.1', username='admin', password='admin')
      my_switch.fetch_vlans()
      my_switch.vlans.add(id='911', name="Vlan911")
      is_ok, msgs = my_switch.commit()
      print(is_ok)


  results:

      True



  Nexus switch

      from cscmiko.devices import NexusSwitch
      my_switch = NexusSwitch(host='192.168.1.2', username='admin', password='admin')
      my_switch.fetch_vpc()

      print("list of up VPCs :")
      for vpc in my_switch.vpcs:
          if vpc.is_up:
              print("id:",vpc.id,"- port: ",vpc.port)

  results:

      list of up VPCs :
      id: 1 - port:  Po99



  Please read [CONTRIBUTING.md](https://github.com/Ali-aqrabawi/cscmiko/blob/master/CONTRIBUTION.md)  for details on our code of conduct, and the process for submitting pull requests to us.


pkgId: 7a43b59909d664028cd0bc154a1b050217aa59d82375bd9ba779ff067451223e
name: python-csdmpy
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: A python module for the core scientific dataset model.
url: https://github.com/DeepanshS/csdmpy/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csdmpy-0.7.0-1.src.rpm
checksum_type: sha256
description:
  The data model is _versatile_ in allowing many **use cases for most spectroscopy,
  diffraction, and imaging techniques**.
  ![](/docs/_static/csdm.png "")

  The model supports multi-component datasets associated with continuous
  physical quantities that are discretely sampled in a multi-dimensional space
  associated with other carefully controlled quantities, for e.g., a mass as a
  function of temperature, a current as a function of voltage and time, a signal
  voltage as a function of magnetic field gradient strength, a color image with
  a red, green, and blue (RGB) light intensity components as a function of two
  independent spatial dimensions, or the six components of the symmetric
  second-rank diffusion tensor MRI as a function of three independent spatial
  dimensions. Additionally, the model supports multiple dependent variables
  sharing the same _d_-dimensional coordinate space. For instance,
  the simultaneous measurement of current and voltage as a function of time.
  Another example would be the simultaneous acquisition of air temperature,
  pressure, wind velocity, and
  solar-flux as a function of Earth’s latitude and longitude coordinates. We
  refer to these dependent variables as _correlated-datasets_.
  **Example**
  ```py
  "csdm": {
    "version": "1.0",
    
    "dimensions": [{
      "type": "linear",
      "count": 1608,
      "increment": "0.08333333333 yr",
      "coordinates_offset": "1880.0416666667 yr",
    }],
    
    "dependent_variables": [{
      "type": "internal",
      "unit": "mm",
      "numeric_type": "float32",
      "quantity_type": "scalar",
      "component_labels": ["GMSL"],
      "components": [
        ["-183.0, -171.125, ..., 59.6875, 58.5"]
      ]
    }]
  }
  ```

      $ pip install csdmpy

  Please cite the following when used in publication.
  1. Srivastava D.J., Vosegaard T., Massiot D., Grandinetti P.J. (2020) Core Scientific Dataset Model: A lightweight and portable model and file format for multi-dimensional scientific data. [PLOS ONE 15(1): e0225953.](https://doi.org/10.1371/journal.pone.0225953)

  - [<img src="https://inc.cnrs.fr/sites/institut_inc/files/styles/top_left/public/image/cnrs_20180120_0025%20%281%29.jpg?itok=i3wlyGBq" height="64" width="64"> Des chimistes élaborent un nouveau format pour le partage de données scientifiques](https://inc.cnrs.fr/fr/cnrsinfo/des-chimistes-elaborent-un-nouveau-format-pour-le-partage-de-donnees-scientifiques)
  - [<img src="https://www.technology.org/texorgwp/wp-content/uploads/2020/01/1920_data-1536x1024.jpg" height="64" width="64"> Simplifying how scientists share data](https://www.technology.org/2020/01/03/simplifying-how-scientists-share-data/)


pkgId: 0600f0a29a1666bd523176943a4ff9ee5b58713306bab2dac7e27d55bd67b1a8
name: python-cse355-machine-design
arch: src
version: 0.2.1
epoch: 0
release: 1
url: https://github.com/DaymudeLab/CSE355-MachineDesign
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cse355-machine-design-0.2.1-1.src.rpm
checksum_type: sha256
summary:
  A python library to allow students to complete machine design problems in ASU's CSE 355 Online offering

description:
  A python library to allow students to complete machine design problems in ASU's CSE 355 Online offering

  > [!IMPORTANT]
  > Currently only DFAs and NFAs are supported. PDAs and Turing Machines are in the works for the next few releases.



  > [!IMPORTANT]
  >  **Requires: Python 3.10+ to use**

  This library can be installed via the command:
  ```bash
  pip install cse355-machine-design
  ```


  This library has four main usage aspects: machine defintion, machine simulation, machine visualization, and machine submission.

  Machine definition involves defining a machine with a formal mathematical definition. This library borrows its syntax heavily from Michael Sipser's
  *Introduction to the Theory of Computation* [^1].

  [^1]: https://math.mit.edu/~sipser/book.html

  See below for example defintions for various machine types



  In order to define a deterministic finite automata (or DFA) in this library, we can use the following example as a guide:
  ```python
  from cse355_machine_design import DFA

  Q = {"q0", "q1"}
  Sigma = {"0", "1"}
  delta = {
      ("q0", "0"): "q0",
      ("q0", "1"): "q1",
      ("q1", "0"): "q0",
      ("q1", "1"): "q1",
  }
  q0 = "q0"
  F = {"q0"}

  M = DFA(Q, Sigma, delta, q0, F)
  ```

  Here we are defining a DFA called `M` with:
  1. the states `q0` and `q1` (denoted by `Q`)
  2. an alphabet containing only `0` and `1` (denoted by `Sigma`)
  3. a transition function (denoted by `delta`) that maps a `current state, input symbol` pair to a new state.
  4. a start state (denoted by `q0`)
  5. and a set of final states (denoted by `F`)

  Together these make up the 5-tuple discussed in Sipser on page 35.

  When defining such DFAs, replace the definitions of each variable as you see fit. When you run the code, the library will let you know if your DFA is **invalid** in the sense that it violates one of the restrictions of DFAs. A not necessarily comprehensive list of possible violations is found below:
  + Not all states found in transition function
  + Transition function contains states not defined in the state set
  + Transition function contains symbols not defined in the alphabet
  + Start state is not found in the state set
  + Some final/accepting states are not valid states.



  There are very few differences between NFAs and DFAs in this library, but for completeness here is an example covering the common ways to define an NFA:

  ```python
  from cse355_machine_design import NFA

  Q = {"q0", "q1", "q2"}
  Sigma = {"0", "1"}
  delta = {
      ("q0", "0"): {"q0", "q1"},
      ("q1", "1"): {"q2"},
      ("q2", "_"): {"q0"}
  }
  q0 = "q0"
  F = {"q2"}

  M = NFA(Q, Sigma, delta, q0, F)
  ```
  The syntax and semantics are identical to the DFA, however we change the constructor to `NFA` and are no longer as constrained when defining our transition function `delta`.

  Additionally, we can see the use of the character `_` in the transition function. This is the character used by default to represent epsilon transitions.

  > [!NOTE]
  > In the rare cases in which you would like to have `_` as part of your input symbols, you can change the character representing epsilon via the constructor:
  > ```python
  > M = NFA(Q, Sigma, delta, q0, F, epsilon_char="$")
  > ```
  > Here we define the machine to treat `_` as a normal input symbol and to use `$` for epsilon internally.
  >
  > Do note that this feature should be used as little as possible as it causes the library to perform additional runtime checks and may cause errors in existing codebases.



  PDAs or Push Down Automata are similar to NFA but with the added ability to use a depth-unlimited stack data structure for memory.

  Heres how you can define one in code:
  ```python
  from cse355_machine_design import PDA

  Q = {"q1", "q2", "q3", "q4"}
  Sigma = {"0", "1"}
  Gamma = {"0", "$"}
  q0 = "q1"
  F = {"q1", "q4"}
  delta = {
      ("q1", "_", "_"): {("q2", "$")},
      ("q2", "0", "_"): {("q2", "0")},
      ("q2", "1", "0"): {("q3", "_")},
      ("q3", "1", "0"): {("q3", "_")},
      ("q3", "_", "$"): {("q4", "_")},
  }

  M = PDA(Q, Sigma, Gamma, delta, q0, F)
  ```

  Unlike NFAs and DFAs, PDAs are a 6-tuple. The new addition is the stack alphabet `Gamma`.
  This is a set of characters that represent what can be stored in the stack.

  Delta is similarly changed to incorporate the appearance of the stack.

  In code we define delta as a dictionary, where the entries are of the form:
  `(Q,A,B): {(R,C), ...}` where:
  + Q is the state you are traveling from
  + A is the input symbol you are reading (optionally epsilon)
  + B is the stack symbol you are popping from the top of the stack (optionally epsilon)
  + R is the state you are going to
  + C is the stack symbol you are pushing onto the top of the stack (optionally epsilon)

  The notation `{(R,C), ...}` represents that we can repeat multiple `(R,C)` pairs in a set format




  An additional feature of this library is to perform simulation of a machine on a given input string.

  > [!NOTE]
  > The syntax is the same across all machine types.



  We can check if a string is accepted using the `evaluate` method found on all machine objects.

  ```python
  M.evaluate("10100")
  ```

  This evaluates the machine `M` on the input string `10100`.

  If there is a mismatch between the charaters in the string and the alphabet of the machine, the library will throw an error.

  The method returns a `bool` representing if the machine accepted or rejected the string.

  > [!WARNING]
  > When evaluating PDAs a memory and time overhead is incurred with respect to the length of the input string.
  > When testing many strings keep the average string length low as it can slow down performance by a lot.
  > When testing a single string, attempting to evaluate strings greater than length 500 may take dozens of seconds on slower systems.
  > The time complexity is not great either, so further increases will result in even higher slowdowns.



  When testing automata it is often very helpful to have some level of feedback on how strings are being evaluated.

  If you wish to enable tracing, use the `enable_trace` flag in the `evaluate` method.

  ```python
  M.evaluate("10100", enable_trace = 1)
  ```

  Here we are going to check if `M` accepts or rejects the string `10100` with a **trace level** of `1`. A trace level is an integer representing how much tracing to do. A lower number (minimum 0: no tracing) represents less tracing and a higher number represents more tracing.

  Different machine types offer different maximum tracing levels. The current maximums can be seen here:

  | Machine Type | Max. Tracing Level |
  | ------------ | ------------------ |
  | DFA          | 1                  |
  | NFA          | 2                  |



  This entire time we have been discussing the formal definitions of machines, however it is often nice to have a state diagram to visualize the machine. This aids in the design loop by providing visual feedback on the automatas structure.

  To create a state diagram, we can make use of the `display_state_diagram` method on any machine object:

  ```python
  M.display_state_diagram()
  ```

  This code will generate an HTML file containing your state diagram in the current directory and will **automatically** open your default web browser to render the file.

  A sample screenshot of a generated state diagram is seen below:

  ![A sample state diagram generated by the library](assets/README_state_diagram.png)



  Especially important for academic use of this library is the functionality to export student work for submission.

  When preparing your machines for submission follow the guide below:

  Please consider the following example question set:

  > 1. Design a DFA that accepts the language {w | w is of even length}
  > 2. Design a DFA that accepts the language {w | w has at least three zeros}

  Suppose you write your two defintions that you decided to call `M_EVEN` and `M_THREE_Z`.

  Before you do anything else, first add the following line of code to the top of the file:

  ```python
  from cse355_machine_design import registry
  ```

  Next suppose you want to submit `M_EVEN` for the first problem. Then, after your machine definition, you would write:

  ```python
  M_EVEN.submit_as_answer(1)
  ```

  For question two you would write:

  ```python
  M_THREE_Z.submit_as_answer(2)
  ```

  Finally, you can add the following line to the bottom of the file:
  ```python
  registry.export_submissions()
  ```

  That will create a JSON file called `submissions.json` that you can upload to Gradescope.

  > [!TIP]
  > It may help to comment out the calls to `display_state_diagram` in order to make the whole generation process faster and more consistent.


pkgId: 113708de658f4cbc360881c6282b888c5992cfbdde9f5afef13370fba4b7c1ae
name: python-cse355-machine-design
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Automata and Turing machine library for ASU's CSE 355.
url: https://github.com/DaymudeLab/CSE355-MachineDesign
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cse355-machine-design-0.3.0-1.src.rpm
checksum_type: sha256
description:
  A Python library for defining, simulating, visualizing, and interacting with automata and Turing machines in Arizona State University's CSE 355: Introduction to Theoretical Computer Science courses.



  > [!IMPORTANT]
  > **Requires Python 3.10 or later**.

  This library can be installed via the command:
  ```bash
  pip install cse355-machine-design
  ```



  > [!NOTE]
  > This documentation covers DFAs, NFAs, and PDAs but is missing the busy beaver Turing machines introduced in release v0.3.0.
  > ASU students should refer to the examples given in the assignment instruction documents for details.

  This library has four main usage aspects: machine defintion, machine simulation, machine visualization, and machine submission.

  Machine definition involves defining a machine with a formal mathematical definition. This library borrows its syntax heavily from Michael Sipser's
  *Introduction to the Theory of Computation* [^1].

  [^1]: https://math.mit.edu/~sipser/book.html

  See below for example defintions for various machine types



  In order to define a deterministic finite automata (or DFA) in this library, we can use the following example as a guide:
  ```python
  from cse355_machine_design import DFA

  Q = {"q0", "q1"}
  Sigma = {"0", "1"}
  delta = {
      ("q0", "0"): "q0",
      ("q0", "1"): "q1",
      ("q1", "0"): "q0",
      ("q1", "1"): "q1",
  }
  q0 = "q0"
  F = {"q0"}

  M = DFA(Q, Sigma, delta, q0, F)
  ```

  Here we are defining a DFA called `M` with:
  1. the states `q0` and `q1` (denoted by `Q`)
  2. an alphabet containing only `0` and `1` (denoted by `Sigma`)
  3. a transition function (denoted by `delta`) that maps a `current state, input symbol` pair to a new state.
  4. a start state (denoted by `q0`)
  5. and a set of final states (denoted by `F`)

  Together these make up the 5-tuple discussed in Sipser on page 35.

  When defining such DFAs, replace the definitions of each variable as you see fit. When you run the code, the library will let you know if your DFA is **invalid** in the sense that it violates one of the restrictions of DFAs. A not necessarily comprehensive list of possible violations is found below:
  + Not all states found in transition function
  + Transition function contains states not defined in the state set
  + Transition function contains symbols not defined in the alphabet
  + Start state is not found in the state set
  + Some final/accepting states are not valid states.



  There are very few differences between NFAs and DFAs in this library, but for completeness here is an example covering the common ways to define an NFA:

  ```python
  from cse355_machine_design import NFA

  Q = {"q0", "q1", "q2"}
  Sigma = {"0", "1"}
  delta = {
      ("q0", "0"): {"q0", "q1"},
      ("q1", "1"): {"q2"},
      ("q2", "_"): {"q0"}
  }
  q0 = "q0"
  F = {"q2"}

  M = NFA(Q, Sigma, delta, q0, F)
  ```
  The syntax and semantics are identical to the DFA, however we change the constructor to `NFA` and are no longer as constrained when defining our transition function `delta`.

  Additionally, we can see the use of the character `_` in the transition function. This is the character used by default to represent epsilon transitions.

  > [!NOTE]
  > In the rare cases in which you would like to have `_` as part of your input symbols, you can change the character representing epsilon via the constructor:
  > ```python
  > M = NFA(Q, Sigma, delta, q0, F, epsilon_char="$")
  > ```
  > Here we define the machine to treat `_` as a normal input symbol and to use `$` for epsilon internally.
  >
  > Do note that this feature should be used as little as possible as it causes the library to perform additional runtime checks and may cause errors in existing codebases.



  PDAs or Push Down Automata are similar to NFA but with the added ability to use a depth-unlimited stack data structure for memory.

  Heres how you can define one in code:
  ```python
  from cse355_machine_design import PDA

  Q = {"q1", "q2", "q3", "q4"}
  Sigma = {"0", "1"}
  Gamma = {"0", "$"}
  q0 = "q1"
  F = {"q1", "q4"}
  delta = {
      ("q1", "_", "_"): {("q2", "$")},
      ("q2", "0", "_"): {("q2", "0")},
      ("q2", "1", "0"): {("q3", "_")},
      ("q3", "1", "0"): {("q3", "_")},
      ("q3", "_", "$"): {("q4", "_")},
  }

  M = PDA(Q, Sigma, Gamma, delta, q0, F)
  ```

  Unlike NFAs and DFAs, PDAs are a 6-tuple. The new addition is the stack alphabet `Gamma`.
  This is a set of characters that represent what can be stored in the stack.

  Delta is similarly changed to incorporate the appearance of the stack.

  In code we define delta as a dictionary, where the entries are of the form:
  `(Q,A,B): {(R,C), ...}` where:
  + Q is the state you are traveling from
  + A is the input symbol you are reading (optionally epsilon)
  + B is the stack symbol you are popping from the top of the stack (optionally epsilon)
  + R is the state you are going to
  + C is the stack symbol you are pushing onto the top of the stack (optionally epsilon)

  The notation `{(R,C), ...}` represents that we can repeat multiple `(R,C)` pairs in a set format




  An additional feature of this library is to perform simulation of a machine on a given input string.

  > [!NOTE]
  > The syntax is the same across all machine types.



  We can check if a string is accepted using the `evaluate` method found on all machine objects.

  ```python
  M.evaluate("10100")
  ```

  This evaluates the machine `M` on the input string `10100`.

  If there is a mismatch between the charaters in the string and the alphabet of the machine, the library will throw an error.

  The method returns a `bool` representing if the machine accepted or rejected the string.

  > [!WARNING]
  > When evaluating PDAs a memory and time overhead is incurred with respect to the length of the input string.
  > When testing many strings keep the average string length low as it can slow down performance by a lot.
  > When testing a single string, attempting to evaluate strings greater than length 500 may take dozens of seconds on slower systems.
  > The time complexity is not great either, so further increases will result in even higher slowdowns.



  When testing automata it is often very helpful to have some level of feedback on how strings are being evaluated.

  If you wish to enable tracing, use the `enable_trace` flag in the `evaluate` method.

  ```python
  M.evaluate("10100", enable_trace = 1)
  ```

  Here we are going to check if `M` accepts or rejects the string `10100` with a **trace level** of `1`. A trace level is an integer representing how much tracing to do. A lower number (minimum 0: no tracing) represents less tracing and a higher number represents more tracing.

  Different machine types offer different maximum tracing levels. The current maximums can be seen here:

  | Machine Type | Max. Tracing Level |
  | ------------ | ------------------ |
  | DFA          | 1                  |
  | NFA          | 2                  |



  This entire time we have been discussing the formal definitions of machines, however it is often nice to have a state diagram to visualize the machine. This aids in the design loop by providing visual feedback on the automatas structure.

  To create a state diagram, we can make use of the `display_state_diagram` method on any machine object:

  ```python
  M.display_state_diagram()
  ```

  This code will generate an HTML file containing your state diagram in the current directory and will **automatically** open your default web browser to render the file.

  A sample screenshot of a generated state diagram is seen below:

  ![A sample state diagram generated by the library](assets/README_state_diagram.png)



  Especially important for academic use of this library is the functionality to export student work for submission.

  When preparing your machines for submission follow the guide below:

  Please consider the following example question set:

  > 1. Design a DFA that accepts the language {w | w is of even length}
  > 2. Design a DFA that accepts the language {w | w has at least three zeros}

  Suppose you write your two defintions that you decided to call `M_EVEN` and `M_THREE_Z`.

  Before you do anything else, first add the following line of code to the top of the file:

  ```python
  from cse355_machine_design import registry
  ```

  Next suppose you want to submit `M_EVEN` for the first problem. Then, after your machine definition, you would write:

  ```python
  M_EVEN.submit_as_answer(1)
  ```

  For question two you would write:

  ```python
  M_THREE_Z.submit_as_answer(2)
  ```

  Finally, you can add the following line to the bottom of the file:
  ```python
  registry.export_submissions()
  ```

  That will create a JSON file called `submissions.json` that you can upload to Gradescope.

  > [!TIP]
  > It may help to comment out the calls to `display_state_diagram` in order to make the whole generation process faster and more consistent.


pkgId: 2a55ea4d4173842a8cec541dc785e54aa3d1aaae43167b39b78cab0971ca99c1
name: python-cse587Autils
arch: src
version: 3.2.1
epoch: 0
release: 1
summary: A set of classes and functions to be used in CSE 587A
url: https://pypi.org/project/cse587Autils/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cse587Autils-3.2.1-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/Chase-Mateusiak/cse587Autils/actions/workflows/python-package.yml/badge.svg)](https://github.com/Chase-Mateusiak/cse587Autils/actions/workflows/python-package.yml)



  This package stores objects, functions and at some point possibly data for
  Michael Brent's CSE 587A: Algorithms for Computational Biology at Washington
  University.

  [See the documentation here](https://cse587a.github.io/cse587Autils/)





  This is on PyPI and may be installed with pip:

  ```bash
  pip install cse587Autils
  ```



  It is possible that the `dev` branch is ahead of `main` and the `pypi` version.
  However, `dev` is not necessarily as stable. Install the `dev` version at your
  own risk:

  ```bash
  pip install https://github.com/Chase-Mateusiak/cse587Autils.git@dev
  ```



  If you want to participate in improving this repository, then fork the repo
  into your own profile. Issue pull requests against `dev`.



  A development container is configured such that after you fork the repo, you
  can launch a codespace with a pre-configured environment and start coding
  right away. Changes you make will be pushed to your fork, and from there you
  can issue pull requests against this repo.


pkgId: 4018898bd03e764a1a619cf00b22a9298d456b0199a2b0ffc477b145eed5ff5f
name: python-csfloat.py
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: A Python wrapper for the csfloat API
url: https://pypi.org/project/csfloat.py/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csfloat.py-0.0.2-1.src.rpm
checksum_type: sha256
description:
  **Python 3.10 or higher is required**
  To install the library, you can just run the following command:
  ```bash

  $ python3 -m pip install -U csfloat.py

  > py -3 -m pip install -U csfloat.py
  ```
  To install the development version, do the following:
  ```bash
  $ git clone https://github.com/PaxxPatriot/csfloat.py.git
  $ cd csfloat.py
  $ python3 -m pip install -U .
  ```


pkgId: ef960c6f8990a7f07020d9587985484a20f031ca6ffffd51bb9dd0f53fc6e42d
name: python-csg-pywaapi
arch: src
version: 1.1.20
epoch: 0
release: 1
url: https://github.com/simongumbleton/csg_pywaapi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csg-pywaapi-1.1.20-1.src.rpm
checksum_type: sha256
summary:
  Helper package for interfacing with Wwise using waapi. csg_pywaapi is no longer support, please use pss-pywaapi instead

description:
  Warning! csg-pywaapi has been renamed pss-pywaapi. The older csg-pywaapi module will no longer be supported, please change your code to use the new pss-pywaapi module.



  Import the library...
  "import csg_pywaapi"

  Connect to Wwise and get the connection info...
  "result = csg_pywaapi.connect()"

  Default port is 8095, Optionally pass in an alternative port for the connection ...
  "result = csg_pywaapi.connect(8080)"


  https://csg-pywaapi.readthedocs.io/


pkgId: 2621c9b9e3667d3e87767a7338166b14c87f72ea78b7bb201a76058c81470586
name: python-csghub-sdk
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/csghub-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csghub-sdk-0.4.5-1.src.rpm
checksum_type: sha256
description:
  <p align="left">
      English ｜ <a href="https://github.com/OpenCSGs/csghub-sdk/blob/main/README_cn.md">中文</a>
  </p>




  The CSGHub SDK is a powerful Python client specifically designed to interact seamlessly with the CSGHub server. This toolkit is engineered to provide Python developers with an efficient and straightforward method to operate and manage remote CSGHub instances. Whether you're looking to automate tasks, manage data, or integrate CSGHub functionalities into your Python applications, the CSGHub SDK offers a comprehensive set of features to accomplish your goals with ease.



  With just a few lines of code, you can seamlessly and quickly switch the model download URL to [OpenCSG](https://opencsg.com/), [enhancing the download speed of models](#quickly-switch-download-urls).

  Effortlessly connect and interact with CSGHub server instances from your Python code.

  Comprehensive API Coverage: Full access to the wide array of functionalities provided by the CSGHub server, ensuring you can perform a broad spectrum of operations.

  User-Friendly: Designed with simplicity in mind, making it accessible for beginners while powerful enough for advanced users.

  Efficient Data Management: Streamline the process of managing and manipulating data on your CSGHub server.

  Automation Ready: Automate repetitive tasks and processes, saving time and reducing the potential for human error.

  Open Source: Dive into the source code, contribute, and customize the SDK to fit your specific needs.

  The main functions are:

  1. Repo downloading（model/dataset）
  2. Repo information query（Compatible with huggingface）



  Visit [OpenCSG](https://opencsg.com/), click on Sign Up in the top right corner to complete the user registration process. Use the successfully registered username and password to log in to [OpenCSG](https://opencsg.com/). After logging in, find [Access Token](https://opencsg.com/settings/access-token) under Account Settings to obtain the token.



  To get started with the CSGHub SDK, ensure you have Python installed on your system. Then, you can install the SDK using pip:

  ```python
  pip install csghub-sdk
  ```

  After installation, you can begin using the SDK to connect to your CSGHub server by importing it into your Python script:

  ```python
  import os
  from pycsghub.repo_reader import AutoModelForCausalLM, AutoTokenizer

  os.environ['CSG_TOKEN'] = 'your_access_token'

  mid = 'OpenCSG/csg-wukong-1B'
  model = AutoModelForCausalLM.from_pretrained(mid)
  tokenizer = AutoTokenizer.from_pretrained(mid)

  inputs = tokenizer.encode("Write a short story", return_tensors="pt")
  outputs = model.generate(inputs)
  print('result: ',tokenizer.batch_decode(outputs))
  ```



  By simply changing the import package name from `transformers` to `pycsghub.repo_reader` and setting the download token, you can seamlessly and quickly switch the model download URL.

  ```python
  os.environ['CSG_TOKEN'] = 'token-of-your'
  from pycsghub.repo_reader import AutoModelForCausalLM, AutoTokenizer
  ```



  ```shell
  git clone https://github.com/OpenCSGs/csghub-sdk.git
  cd csghub-sdk
  pip install .
  ```

  You can install the dependencies related to the model and dataset using `pip install '.[train]'`, for example:

  ```shell
  pip install '.[train]'
  ```



  ```shell
  export CSG_TOKEN=your_access_token


  csghub-cli download wanghh2000/myprivate1


  csghub-cli download wanghh2000/myds1 -t dataset


  csghub-cli upload wanghh2000/myprivate1 abc/3.txt


  csghub-cli upload wanghh2000/myds1 abc/4.txt abc/5.txt -t dataset
  ```

  Download location is `~/.cache/csg/` by default.



  For more detailed instructions, including API documentation and usage examples, please refer to the Use case.



  ```python
  from pycsghub.snapshot_download import snapshot_download
  token = "your_access_token"

  endpoint = "https://hub.opencsg.com"
  repo_id = 'OpenCSG/csg-wukong-1B'
  cache_dir = '/Users/hhwang/temp/'
  result = snapshot_download(repo_id, cache_dir=cache_dir, endpoint=endpoint, token=token)
  ```


  ```python
  from pycsghub.snapshot_download import snapshot_download
  token="xxxx"
  endpoint = "https://hub.opencsg.com"
  repo_id = 'AIWizards/tmmluplus'
  repo_type="dataset"
  cache_dir = '/Users/xiangzhen/Downloads/'
  result = snapshot_download(repo_id, repo_type=repo_type, cache_dir=cache_dir, endpoint=endpoint, token=token)
  ```



  Use `http_get` function to download single file

  ```python
  from pycsghub.file_download import http_get
  token = "your_access_token"

  url = "https://hub.opencsg.com/api/v1/models/OpenCSG/csg-wukong-1B/resolve/tokenizer.model"
  local_dir = '/home/test/'
  file_name = 'test.txt'
  headers = None
  cookies = None
  http_get(url=url, token=token, local_dir=local_dir, file_name=file_name, headers=headers, cookies=cookies)
  ```

  use `file_download` function to download single file from a repository

  ```python
  from pycsghub.file_download import file_download
  token = "your_access_token"

  endpoint = "https://hub.opencsg.com"
  repo_id = 'OpenCSG/csg-wukong-1B'
  cache_dir = '/home/test/'
  result = file_download(repo_id, file_name='README.md', cache_dir=cache_dir, endpoint=endpoint, token=token)
  ```



  ```python
  from pycsghub.file_upload import http_upload_file

  token = "your_access_token"

  endpoint = "https://hub.opencsg.com"
  repo_type = "model"
  repo_id = 'wanghh2000/myprivate1'
  result = http_upload_file(repo_id, endpoint=endpoint, token=token, repo_type='model', file_path='test1.txt')
  ```



  ```python
  from pycsghub.file_upload import http_upload_file

  token = "your_access_token"

  endpoint = "https://hub.opencsg.com"
  repo_type = "model"
  repo_id = 'wanghh2000/myprivate1'

  repo_files = ["1.txt", "2.txt"]
  for item in repo_files:
      http_upload_file(repo_id=repo_id, repo_type=repo_type, file_path=item, endpoint=endpoint, token=token)
  ```



  Before starting, please make sure you have Git-LFS installed (see [here](https://git-lfs.github.com/) for installation instructions).

  ```python
  from pycsghub.repository import Repository

  token = "your access token"

  r = Repository(
      repo_id="wanghh2003/ds15",
      upload_path="/Users/hhwang/temp/bbb/jsonl",
      user_name="wanghh2003",
      token=token,
      repo_type="dataset",
  )

  r.upload()
  ```



  The transformers library supports directly inputting the repo_id from Hugging Face to download and load related models, as shown below:

  ```python
  from transformers import AutoModelForCausalLM
  model = AutoModelForCausalLM.from_pretrained('model/repoid')
  ```

  In this code, the Hugging Face Transformers library first downloads the model to a local cache folder, then reads the configuration, and loads the model by dynamically selecting the relevant class for instantiation.

  To ensure compatibility with Hugging Face, version 0.2 of the CSGHub SDK now includes the most commonly features: downloading and loading models. Models can be downloaded and loaded as follows:

  ```python


  from pycsghub.repo_reader import AutoModelForCausalLM
  model = AutoModelForCausalLM.from_pretrained('model/repoid')
  ```

  This code:

  1. Use the `snapshot_download` from the CSGHub SDK library to download the related files.

  2. By generating batch classes dynamically and using class name reflection mechanism, a large number of classes with the same names as those automatically loaded by transformers are created in batches.

  3. Assign it with the from_pretrained method, so the model read out will be an hf-transformers model.



  1. Dataset Download
  2. Interacting with CSGHub via command-line tools
  3. Management operations such as creation and modification of CSGHub repositories
  4. Model deployment locally or online
  5. Model fine-tuning locally or online
  6. Publishing the model to a remote hosting repository


pkgId: e799097b0cf73d2592c68f412f26889e5658497c809fd1e474cfb9b31d3c9fc7
name: python-cshelve
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Propulsing the shelve module to the cloud
url: https://pypi.org/project/cshelve/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cshelve-0.5.0-1.src.rpm
checksum_type: sha256
description:
  `Cloud Shelve (cshelve)` is a Python package that provides a seamless way to store and manage data in the cloud using the familiar [Python Shelve interface](https://docs.python.org/3/library/shelve.html). It is designed for efficient and scalable storage solutions, allowing you to leverage cloud providers for persistent storage while keeping the simplicity of the `shelve` API.



  - Supports large file storage in the cloud
  - Secure data in-transit encryption when using cloud storage
  - Fully compatible with Python's `shelve` API
  - Cross-platform compatibility for local and remote storage



  Install `cshelve` via pip:

  ```bash
  pip install cshelve
  ```



  The `cshelve` module strictly follows the official `shelve` API. Consequently, you can refer to the [Python official documentation](https://docs.python.org/3/library/shelve.html) for general usage examples. Simply replace the `shelve` import with `cshelve`, and you're good to go.



  Here is an example, adapted from the [official shelve documentation](https://docs.python.org/3/library/shelve.html#example), demonstrating local storage usage. Just replace `shelve` with `cshelve`:

  ```python
  import cshelve

  d = cshelve.open('local.db')  # Open the local database file

  key = 'key'
  data = 'data'

  d[key] = data                 # Store data at the key (overwrites existing data)
  data = d[key]                 # Retrieve a copy of data (raises KeyError if not found)
  del d[key]                    # Delete data at the key (raises KeyError if not found)

  flag = key in d               # Check if the key exists in the database
  klist = list(d.keys())        # List all existing keys (could be slow for large datasets)


  d['xx'] = [0, 1, 2]           # Store a list
  d['xx'].append(3)             # This won't persist since writeback=True is not used


  temp = d['xx']                # Extract the stored list
  temp.append(5)                # Modify the list
  d['xx'] = temp                # Store it back to persist changes

  d.close()                     # Close the database
  ```



  For testing purposes, it is possible to use an in-memory provider that can:
  - Persist the data during all the program execution.
  - Remove the data object is deleted.

  Here is a configuration example:
  ```bash
  $ cat in-memory.ini
  [default]
  provider    = in-memory

  persist-key = standard
  ```

  A common use case for this provider is to simplify mocking.

  Example:
  ```bash
  $ cat persist.ini
  [default]
  provider    = in-memory

  persist-key = my-db

  $ cat do-not-persist.ini
  [default]
  provider = in-memory
  ```

  ```python
  import cshelve

  with cshelve.open('persist.ini') as db:
      db["Asterix"] = "Gaulois"

  with cshelve.open('persist.ini') as db:
      assert db["Asterix"] == "Gaulois"

  with cshelve.open('do-not-persist.ini') as db:
      db["Obelix"] = "Gaulois"

  with cshelve.open('do-not-persist.ini') as db:
      assert "Obelix" not in db
  ```



  To configure remote cloud storage, you need to provide an INI file containing your cloud provider's configuration. The file should have a `.ini` extension. Remote storage also requires the installation of optional dependencies for the cloud provider you want to use.



  First, install the Azure Blob Storage provider:
  ```bash
  pip install cshelve[azure-blob]
  ```

  Then, create an INI file with the following configuration:
  ```bash
  $ cat azure-blob.ini
  [default]
  provider        = azure-blob
  account_url     = https://myaccount.blob.core.windows.net


  auth_type       = passwordless
  container_name  = mycontainer
  ```

  Once the INI file is ready, you can interact with remote storage the same way as with local storage. Here's an example using Azure:

  ```python
  import cshelve

  d = cshelve.open('azure-blob.ini')  # Open using the remote storage configuration

  key = 'key'
  data = 'data'

  d[key] = data                  # Store data at the key on the remote storage
  data = d[key]                  # Retrieve the data from the remote storage
  del d[key]                     # Delete the data from the remote storage

  flag = key in d                # Check if the key exists in the cloud storage
  klist = list(d.keys())         # List all keys present in the remote storage


  d['xx'] = [0, 1, 2]            # Store a list on the remote storage
  d['xx'].append(3)              # This won't persist since writeback=True is not used


  temp = d['xx']                 # Extract the stored list from the remote storage
  temp.append(5)                 # Modify the list locally
  d['xx'] = temp                 # Store it back on the remote storage to persist changes

  d.close()                      # Close the connection to the remote storage
  ```

  More configuration examples for other cloud providers can be found [here](./tests/configurations/).





  Provider: `in-memory`
  Installation: No additional installation required.

  The In Memory provider uses an in-memory data structure to simulate storage. This is useful for testing and development purposes.

  | Option         | Description                                                                  | Required | Default Value |
  |----------------|------------------------------------------------------------------------------|----------|---------------|
  | `persist-key`  | If set, its value will be conserved and reused during the program execution. | :x:      | None          |
  | `exists`       | If True, the database exists; otherwise, it will be created.                 | :x:      | False         |




  Provider: `azure-blob`
  Installation: `pip install cshelve[azure-blob]`

  The Azure provider uses [Azure Blob Storage](https://learn.microsoft.com/en-us/azure/storage/blobs/storage-blobs-introduction) as remote storage.
  The module considers the provided container as dedicated to the application. The impact might be significant. For example, if the flag `n` is provided to the `open` function, the entire container will be purged, aligning with the [official interface](https://docs.python.org/3/library/shelve.html#shelve.open).

  | Option                           | Description                                                                                                                                                  | Required           | Default Value |
  |----------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|---------------|
  | `account_url`                    | The URL of your Azure storage account.                                                                                                                       | :x:                |               |
  | `auth_type`                      | The authentication method to use: `access_key`, `passwordless`, `connection_string` or `anonymous`.                                                                               | :white_check_mark:                |               |
  | `container_name`                 | The name of the container in your Azure storage account.                                                                                                     | :white_check_mark:                |               |

  Depending on the `open` flag, the permissions required by `cshelve` for blob storage vary.

  | Flag | Description | Permissions Needed |
  |------|-------------|--------------------|
  | `r`  | Open an existing blob storage container for reading only. | [Storage Blob Data Reader](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#storage-blob-data-reader) |
  | `w`  | Open an existing blob storage container for reading and writing. | [Storage Blob Data Contributor](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#storage-blob-data-contributor) |
  | `c`  | Open a blob storage container for reading and writing, creating it if it doesn't exist. | [Storage Blob Data Contributor](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#storage-blob-data-contributor) |
  | `n`  | Purge the blob storage container before using it. | [Storage Blob Data Contributor](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#storage-blob-data-contributor) |


  Authentication type supported:

  | Auth Type         | Description                                                                                     | Advantage                                                                 | Disadvantage                          | Example Configuration |
  |-------------------|-------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------|---------------------------------------|-----------------------|
  | Access Key       | Uses an Access Key or a Shared Access Signature for authentication. | Fast startup as no additional credential retrieval is needed. | Credentials need to be securely managed and provided. | [Example](./tests/configurations/azure-integration/access-key.ini) |
  | Anonymous         | No authentication for anonymous access on public blob storage. | No configuration or credentials needed. | Read-only access. | [Example](./tests/configurations/azure-integration/anonymous.ini) |
  | Connection String | Uses a connection string for authentication. Credentials are provided directly in the string. | Fast startup as no additional credential retrieval is needed. | Credentials need to be securely managed and provided. | [Example](./tests/configurations/azure-integration/connection-string.ini) |
  | Passwordless      | Uses passwordless authentication methods such as Managed Identity. | Recommended for better security and easier credential management. | May impact startup time due to the need to retrieve authentication credentials. | [Example](./tests/configurations/azure-integration/standard.ini) |




  We welcome contributions from the community! Have a look at our [issues](https://github.com/Standard-Cloud/cshelve/issues).



  This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.



  If you have any questions, issues, or feedback, feel free to [open an issue]https://github.com/Standard-Cloud/cshelve/issues).


pkgId: 15aef42fd970f5f993d9b4249b14f01cd1a1d8224865e99257ab14cfeb165f82
name: python-csi-analysis
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: CSI-Cancer analysis pipeline templates.
url: https://pypi.org/project/csi-analysis/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csi-analysis-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/csi-analysis)](https://pypi.org/project/csi-analysis/)

  This package contains classes and functions for running modular analysis pipelines on
  data types commonly used by CSI-Cancer. Currently, this only includes whole-slide
  images (immunoflourescent scans). In particular, this package is meant to provide
  abstract base classes that can be fit into an then run in a standard pipeline. This will
  enable more interchangeability and easier development of new modules, such as for image
  segmentation or feature extraction.

  While much of the functionality is specific to the CSI-Cancer organization, some of the
  functionality and structure may be beneficial for the broader community.
  Other packages in the CSI-Cancer organization may depend on this package.



  Currently, this package contains the main module: `csi_scan_pipeline.py`.
  This module contains the abstract base classes for the pipeline, as well as the
  `ScanPipeline` class, which is the main class for running the pipeline. This class
  contains the `run()` method, which handles parallelization, logging, and passing data
  between the module components. 4



  For more detailed documentation, open up `docs/index.html` in your browser.

  To regenerate the documentation, ensure that you
  have [installed the package](#installation) and then run:

  ```commandline
  make_docs
  ```



  If you haven't yet, make sure
  to [set up an SSH key for GitHub](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent).

  1. Activate your `conda` (`conda activate yourenv`) or
     `venv` (`source path/to/your/venv/bin/activate`) environment first.
  2. Clone `csi_images` and install:

  ```commandline
  cd ~/path/to/your/repositories
  git clone git@github.com:CSI-Cancer/csi_analysis.git
  pip install ./csi_analysis
  ```

  Alternatively, you can "editable" install the package, which will allow you to make
  changes to the package and have them reflected in your environment without reinstalling:

  ```commandline
  pip install -e ./csi_analysis
  ```

  This will add symbolic links to your `site-packages` directory instead of copying the
  package files over.


pkgId: 0debb7978c1e66d053c15cd205250ae2333348d15b602759f11aa3f052a10e2a
name: python-csi-images
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: CSI-Cancer image data structure and basic processing.
url: https://github.com/CSI-Cancer/csi_images
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csi-images-1.1.3-1.src.rpm
checksum_type: sha256
description:
  This package contains classes and functions for interacting with images and image data.
  While much of the functionality is specific to the CSI-Cancer organization, some of the
  functionality and structure may be beneficial for the broader community.
  Other packages in the CSI-Cancer organization may depend on this package.

  Install with:

  ```
  pip install csi_images
  ```



  This package contains these modules:

  1. `csi_scans.py`: a module for interacting with scan-level files, such as .czi files.
      * `Scan`: a class that contains all of the scan metadata. for interacting with scan
        metadata, such as the slide ID, the path to the scan, and scan parameters.
        Recommend importing via `from csi_images.csi_scans import Scan`
  2. `csi_tiles.py`: a module for interacting with tiles, which have a particular (x, y)
     position in the scan. Tiles have several frames taken at the same position.
      * `Tile`: a class for containing a tile's positional data. Imports `csi_scans.py`.
        This class unifies multiple scanners' tile positioning to convert between index
        and (x, y). Recommend importing via `from csi_images.csi_tiles import Tile`
  3. `csi_frames.py`: a module for interacting with frames, which are individual images.
     Imports `csi_scans.py` and `csi_tiles.py`. Recommend importing via
     `from csi_images.csi_frames import Frame`
      * `Frame`: a class for containing a frame's metadata. Each frame in a tile has a
        different channel, or light spectrum. The frame **only contains metadata**, but
        enables gathering of the image data through the `get_image()` method. For a list
        of frames, use `get_frames()`. For all frames in a scan, use `get_all_frames()`.
        For many frames, use `[frame.get_image() for frame in frames]`. Recommend
        importing via `from csi_images.csi_frames import Frame`
  4. `csi_events.py`: a module for interacting with individual events. Imports
     `csi_scans.py`, `csi_tiles.py`, and `csi_frames.py`.
      * `Event`: a class for containing a single event's metadata and feature data. Key
        metadata (scan, tile, x, y) is required; the others are optional and flexible.
        Contains a convenience function for getting crops of an event, as well as
        functions for determining the position of the event in the slide coordinate frame.
        Recommend importing via `from csi_images.csi_events import Event`
      * `EventArray`: a class for containing a list of events, holding their data in
        pandas dataframes. Contains functions converting back and forth from `Event`s and
        files. Recommend importing via `from csi_images.csi_events import EventArray`



  * `Event.montage()`: Combines crops for an event into side-by-side montages.



  For more detailed documentation, check
  [the API docs](https://csi-cancer.github.io/csi_images/).

  Alternatively, once you have cloned the repository, you
  can open up `docs/index.html` in your browser.

  To regenerate the documentation, ensure that you
  have [installed the package](#installation) and then run:

  ```commandline
  make_docs_for_csi_images
  ```



  1. Activate your `conda` (`conda activate yourenv`) or
     `venv` (`source path/to/your/venv/bin/activate`) environment first.
  2. Clone `csi_images` and install:

  ```commandline
  cd ~/path/to/your/repositories
  git clone git@github.com:CSI-Cancer/csi_images.git
  pip install ./csi_images
  ```

  Alternatively, you can "editable" install the package, which will allow you to make
  changes to the package and have them reflected in your environment without reinstalling:

  ```commandline
  pip install -e ./csi_images
  ```

  This will add symbolic links to your `site-packages` directory instead of copying the
  package files over.


pkgId: 59c998618384c924e571d434f41af08f165d43e80dea4314f30444b8d03b7725
name: python-csi-images
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: CSI-Cancer image data structure and basic processing.
url: https://github.com/CSI-Cancer/csi_images
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csi-images-1.1.4-1.src.rpm
checksum_type: sha256
description:
  [![Coverage Badge](docs/theme/coverage.svg)](https://csi-cancer.github.io/csi_images/coverage)

  This package contains classes and functions for interacting with images and image data.
  While much of the functionality is specific to the CSI-Cancer organization, some of the
  functionality and structure may be beneficial for the broader community.
  Other packages in the CSI-Cancer organization may depend on this package.

  Install with:

  ```
  pip install csi_images
  ```



  This package contains these modules:

  1. `csi_scans.py`: a module for interacting with scan-level files, such as .czi files.
      * `Scan`: a class that contains all of the scan metadata. for interacting with scan
        metadata, such as the slide ID, the path to the scan, and scan parameters.
        Recommend importing via `from csi_images.csi_scans import Scan`
  2. `csi_tiles.py`: a module for interacting with tiles, which have a particular (x, y)
     position in the scan. Tiles have several frames taken at the same position.
      * `Tile`: a class for containing a tile's positional data. Imports `csi_scans.py`.
        This class unifies multiple scanners' tile positioning to convert between index
        and (x, y). Recommend importing via `from csi_images.csi_tiles import Tile`
  3. `csi_frames.py`: a module for interacting with frames, which are individual images.
     Imports `csi_scans.py` and `csi_tiles.py`. Recommend importing via
     `from csi_images.csi_frames import Frame`
      * `Frame`: a class for containing a frame's metadata. Each frame in a tile has a
        different channel, or light spectrum. The frame **only contains metadata**, but
        enables gathering of the image data through the `get_image()` method. For a list
        of frames, use `get_frames()`. For all frames in a scan, use `get_all_frames()`.
        For many frames, use `[frame.get_image() for frame in frames]`. Recommend
        importing via `from csi_images.csi_frames import Frame`
  4. `csi_events.py`: a module for interacting with individual events. Imports
     `csi_scans.py`, `csi_tiles.py`, and `csi_frames.py`.
      * `Event`: a class for containing a single event's metadata and feature data. Key
        metadata (scan, tile, x, y) is required; the others are optional and flexible.
        Contains a convenience function for getting crops of an event, as well as
        functions for determining the position of the event in the slide coordinate frame.
        Recommend importing via `from csi_images.csi_events import Event`
      * `EventArray`: a class for containing a list of events, holding their data in
        pandas dataframes. Contains functions converting back and forth from `Event`s and
        files. Recommend importing via `from csi_images.csi_events import EventArray`



  * `Event.montage()`: Combines crops for an event into side-by-side montages.



  For more detailed documentation, check
  [the API docs](https://csi-cancer.github.io/csi_images/).

  Alternatively, once you have cloned the repository, you
  can open up `docs/index.html` in your browser.

  To regenerate the documentation, ensure that you
  have [installed the package](#installation) and then run:

  ```commandline
  make_docs_for_csi_images
  ```



  1. Activate your `conda` (`conda activate yourenv`) or
     `venv` (`source path/to/your/venv/bin/activate`) environment first.
  2. Clone `csi_images` and install:

  ```commandline
  cd ~/path/to/your/repositories
  git clone git@github.com:CSI-Cancer/csi_images.git
  pip install ./csi_images
  ```

  Alternatively, you can "editable" install the package, which will allow you to make
  changes to the package and have them reflected in your environment without reinstalling:

  ```commandline
  pip install -e ./csi_images
  ```

  This will add symbolic links to your `site-packages` directory instead of copying the
  package files over.


pkgId: 31e5c973b5a7f4132982f41253bf4a16cbb52cc89512e09a50b8257164246eed
name: python-csi-images
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: CSI-Cancer image data structure and basic processing.
url: https://github.com/CSI-Cancer/csi_images
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csi-images-1.3.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/csi-images)](https://pypi.org/project/csi-images/)
  [![Coverage Badge](docs/theme/coverage.svg)](https://csi-cancer.github.io/csi_images/coverage)

  This package is a library for interacting with data, mainly from immunoflourescent
  microscopy, such as cells and the images thereof.
  While much of the functionality is specific to the CSI-Cancer organization, some of the
  functionality and structure may be beneficial for the broader community.
  Other packages in the CSI-Cancer organization may depend on this package.

  Install with:

  ```commandline
  pip install csi_images
  ```

  or

  ```commandline
  pip install csi_images[imageio,rds,dev,all]
  ```

  The base version of the package includes only core data structures and manipulations.

  Optional dependencies include:

  * `imageio`: for reading and writing images, include .czi files.
  * `rds`: for reading and writing RDS files, such as OCULAR outputs.
  * `dev`: for development dependencies, including documentation, tests, building, etc.
  * `all`: for all optional dependencies.



  This package contains these modules:

  1. `csi_scans.py`: a module for interacting with scan-level files, such as .czi files.
      * `Scan`: a class that contains all of the scan metadata. for interacting with scan
        metadata, such as the slide ID, the path to the scan, and scan parameters.
        Recommend importing via `from csi_images.csi_scans import Scan`
  2. `csi_tiles.py`: a module for interacting with tiles, which have a particular (x, y)
     position in the scan. Tiles have several frames taken at the same position.
      * `Tile`: a class for containing a tile's positional data. Imports `csi_scans.py`.
        This class unifies multiple scanners' tile positioning to convert between index
        and (x, y). Recommend importing via `from csi_images.csi_tiles import Tile`
  3. `csi_frames.py`: a module for interacting with frames, which are individual images.
     Imports `csi_scans.py` and `csi_tiles.py`. Recommend importing via
     `from csi_images.csi_frames import Frame`
      * `Frame`: a class for containing a frame's metadata. Each frame in a tile has a
        different channel, or light spectrum. The frame **only contains metadata**, but
        enables gathering of the image data through the `get_image()` method. For a list
        of frames, use `get_frames()`. For all frames in a scan, use `get_all_frames()`.
        For many frames, use `[frame.get_image() for frame in frames]`. Recommend
        importing via `from csi_images.csi_frames import Frame`
  4. `csi_events.py`: a module for interacting with individual events. Imports
     `csi_scans.py`, `csi_tiles.py`, and `csi_frames.py`.
      * `Event`: a class for containing a single event's metadata and feature data. Key
        metadata (scan, tile, x, y) is required; the others are optional and flexible.
        Contains a convenience function for getting crops of an event, as well as
        functions for determining the position of the event in the slide coordinate frame.
        Recommend importing via `from csi_images.csi_events import Event`
      * `EventArray`: a class for containing a list of events, holding their data in
        pandas dataframes. Contains functions converting back and forth from `Event`s and
        files. Recommend importing via `from csi_images.csi_events import EventArray`



  * `Event.montage()`: Combines crops for an event into side-by-side montages.



  For more detailed documentation, check
  [the API docs](https://csi-cancer.github.io/csi_images/).

  Alternatively, once you have cloned the repository, you
  can open up `docs/index.html` in your browser.

  To regenerate the documentation, ensure that you
  have [installed the package](#installation) and then run:

  ```commandline
  make_docs_for_csi_images
  ```



  1. Activate your `conda` (`conda activate yourenv`) or
     `venv` (`source path/to/your/venv/bin/activate`) environment first.
  2. Clone `csi_images` and install:

  ```commandline
  cd ~/path/to/your/repositories
  git clone git@github.com:CSI-Cancer/csi_images.git
  pip install ./csi_images
  ```

  Alternatively, you can "editable" install the package, which will allow you to make
  changes to the package and have them reflected in your environment without reinstalling:

  ```commandline
  pip install -e ./csi_images
  ```

  This will add symbolic links to your `site-packages` directory instead of copying the
  package files over.


pkgId: 8b8b066d7ff8f982dc4c281b14f2b58910f0404cdf3efb96dd8ac80154c18131
name: python-csinsc
arch: src
version: 1.1.0.8
epoch: 0
release: 1
summary: Tools and libraries used in the CSinSchools course
url: https://github.com/toanh/csinsc
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csinsc-1.1.0.8-1.src.rpm
checksum_type: sha256
description:
  Tools and libraries used in the CSinSchools course.
  Includes a trace based goto functionality.
  Incorporates the termcolor library.
  And a simple curses wrapper.


pkgId: 725762c88df59ca1b3e4ed49617dbc028d3ffcc5c4dddb7a4ae653c9610ca142
name: python-csnake
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: C code generation helper package.
url: https://gitlab.com/andrejr/csnake
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csnake-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Csnake's varable generation was motivated by a common embedded development
  task: inputting data into C code.
  Csnake should be of help when generating C code for representing data like
  bitmaps, fonts, statemachines, lookup tables - as arrays and structs.
  It can also be used for loop unrolling, templating, ...
  Csnake  can be easily incorporated into a build system (Make, CMake,
  Scons,...), and also goes along great with Jinja2 and
  `Ned Batchelder's cog <https://nedbatchelder.com/code/cog/>`_.


pkgId: 1b379deca76dc3198971a4bdbb5a319f5c712f87e5c5aadd73f704fbf55ba632
name: python-csnlp
arch: src
version: 1.6.2
epoch: 0
release: 1
summary: Nonlinear Progamming with CasADi
url: https://github.com/FilippoAiraldi/casadi-nlp
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csnlp-1.6.2-1.src.rpm
checksum_type: sha256
description:
  **csnlp** builds on top of the [CasADi](https://web.casadi.org/)
  framework [[1]](#1) to model the optimization problems and perform symbolic
  differentiation, and heavily relies on the [IPOPT](https://github.com/coin-or/Ipopt)
  solver [[2]](#2) (though the package allows the user to seamlessly switch to other
  solvers supported by CasADi). While it is similar in functionality (and was inspired by)
  the CasADi's
  [Opti Stack](https://web.casadi.org/api/html/dd/dc6/classcasadi_1_1Opti.html) (see
  [this blog post](https://web.casadi.org/blog/opti/) for example), it is more tailored to
  research as
  1. it is more flexible, since it is written in Python and allows the user to easily
     access all the constituents of the optimization problem (e.g. the objective function,
     constraints, dual variables, bounds, etc.)
  2. it is more modular, since it allows the base `csnlp.Nlp` class to be wrapped with
     additional functionality (e.g. sensitivity, Model Predictive Control, etc.), and it
     provides parallel implementations in case of multistarting in the `csnlp.multistart`
     module.
  The package offers also tools for the sensitivity analysis of NLPs, solving them with
  multiple initial conditions, as well as for building MPC controllers. The library is not
  meant to be a faster alternative to `casadi.Opti`, but rather a more flexible and


pkgId: e5def2b59ba969f355695c8815e081fcb3db13c09bc7806fbc2a04b32d43187b
name: python-csp-activemq
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: csp-activemq
url: https://github.com/timkpaine/csp-activemq
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csp-activemq-0.0.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024, the csp-activemq authors  Licensed 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 at  http://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.


pkgId: d52588055677933c0e5e899fd8eafa948947d7303c26037bccd8fc35b8c381b2
name: python-csp-adapter-activemq
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: csp-adapter-activemq
url: https://github.com/timkpaine/csp-adapter-activemq
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csp-adapter-activemq-0.0.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024, the csp-adapter-activemq authors  Licensed 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 at  http://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.


pkgId: f2759c80aca0df18a2859a6a8a67d708ff722dcd14f0a4050507855db11368a5
name: python-csp-adapter-odbc
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: csp-adapter-odbc
url: https://github.com/timkpaine/csp-adapter-odbc
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csp-adapter-odbc-0.0.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024, the csp-adapter-odbc authors  Licensed 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 at  http://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.


pkgId: e438d642f17ecfc0a4c1101f34247f81e73f0434a65413901683581a995cc3fb
name: python-csp-adapter-rabbitmq
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: csp-adapter-rabbitmq
url: https://github.com/timkpaine/csp-adapter-rabbitmq
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csp-adapter-rabbitmq-0.0.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024, the csp-adapter-rabbitmq authors  Licensed 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 at  http://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.


pkgId: bc0c1fc23a74957de5c2f67532d9634b1bd67358db6572633255b3d3c335ca02
name: python-csp-adapter-slack
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A csp adapter for slack
url: https://github.com/point72/csp-adapter-slack
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csp-adapter-slack-0.2.0-1.src.rpm
checksum_type: sha256
description:
  A [csp](https://github.com/point72/csp) adapter for [slack](https://slack.com)

  [![Build Status](https://github.com/point72/csp-adapter-slack/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/point72/csp-adapter-slack/actions?query=workflow%3A%22Build+Status%22)
  [![GitHub issues](https://img.shields.io/github/issues/point72/csp-adapter-slack.svg)](https://github.com/point72/csp-adapter-slack/issues)
  [![PyPI](https://img.shields.io/pypi/l/csp-adapter-slack.svg)](https://pypi.python.org/pypi/csp-adapter-slack)
  [![PyPI](https://img.shields.io/pypi/v/csp-adapter-slack.svg)](https://pypi.python.org/pypi/csp-adapter-slack)



  [More information is available in our wiki](https://github.com/Point72/csp-adapter-slack/wiki)



  Install with `pip`:

  ```bash
  pip install csp csp-adapter-slack
  ```

  Install with `conda`

  ```bash
  conda install csp csp-adapter-slack -c conda-forge
  ```



  This software is licensed under the Apache 2.0 license. See the [LICENSE](LICENSE) file for details.

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024 Point72, L..P.  Licensed 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 at  http://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.


pkgId: fac47a15d3c820dcb01e04013746c205e0aee2e82ef35474bebe2d9b80fca18e
name: python-csp-adapter-symphony
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: A csp adapter for symphony
url: https://github.com/point72/csp-adapter-symphony
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csp-adapter-symphony-0.2.1-1.src.rpm
checksum_type: sha256
description:
  A [csp](https://github.com/point72/csp) adapter for [symphony](https://symphony.com)

  [![Build Status](https://github.com/point72/csp-adapter-symphony/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/point72/csp-adapter-symphony/actions?query=workflow%3A%22Build+Status%22)
  [![GitHub issues](https://img.shields.io/github/issues/point72/csp-adapter-symphony.svg)](https://github.com/point72/csp-adapter-symphony/issues)
  [![PyPI](https://img.shields.io/pypi/l/csp-adapter-symphony.svg)](https://pypi.python.org/pypi/csp-adapter-symphony)
  [![PyPI](https://img.shields.io/pypi/v/csp-adapter-symphony.svg)](https://pypi.python.org/pypi/csp-adapter-symphony)



  [More information is available in our wiki](https://github.com/Point72/csp-adapter-symphony/wiki)



  Install with `pip`:

  ```bash
  pip install csp csp-adapter-symphony
  ```

  Install with `conda`

  ```bash
  conda install csp csp-adapter-symphony -c conda-forge
  ```



  This software is licensed under the Apache 2.0 license. See the [LICENSE](LICENSE) file for details.

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024 Point72, L..P.  Licensed 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 at  http://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.


pkgId: 50b97cee8b11f5faf4d8ac7e8f168a2989d67b461c02d8ce29dba9c1db40d8e8
name: python-csp-adapter-zeromq
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: csp-adapter-zeromq
url: https://github.com/timkpaine/csp-adapter-zeromq
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csp-adapter-zeromq-0.0.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024, the csp-adapter-zeromq authors  Licensed 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 at  http://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.


pkgId: b53010227ae9e624b8f9bee112352982bbd6382a0ea32e34e5d66e40b60c7d95
name: python-csp-adapter-zmq
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: csp-adapter-zmq
url: https://github.com/timkpaine/csp-adapter-zmq
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csp-adapter-zmq-0.0.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024, the csp-adapter-zmq authors  Licensed 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 at  http://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.


pkgId: 043aa711dbb3645afe0bbbdbc9f3f694d84ff45675de446e13c902b1de894f86
name: python-csp-odbc
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: csp-odbc
url: https://github.com/timkpaine/csp-odbc
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csp-odbc-0.0.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024, the csp-odbc authors  Licensed 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 at  http://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.


pkgId: 8a563b5a0f5715a57625fcef15ec367affa6f7c643864ced0fefc5dfb7ddf7db
name: python-csp-rabbitmq
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: csp-rabbitmq
url: https://github.com/timkpaine/csp-rabbitmq
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csp-rabbitmq-0.0.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024, the csp-rabbitmq authors  Licensed 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 at  http://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.


pkgId: a45681841758be7a49413d5226be5ca5211330a8788374f3e2d60cab8754567d
name: python-csp-zeromq
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: csp-zeromq
url: https://github.com/timkpaine/csp-zeromq
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csp-zeromq-0.0.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024, the csp-zeromq authors  Licensed 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 at  http://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.


pkgId: b876533c783c3ac07d760fd0fc6814249835e57ea97eb6ff7df88dba014683d3
name: python-csp-zmq
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: csp-zmq
url: https://github.com/timkpaine/csp-zmq
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csp-zmq-0.0.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024, the csp-zmq authors  Licensed 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 at  http://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.


pkgId: 72522d5f5645b2aa5d03637cacdd6b875fee7eab30a24893edab3cb383fc6e58
name: python-cspark
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: A Python SDK for interacting with Coherent Spark APIs
url: https://github.com/Coherent-Partners/spark-python-sdk/blob/main/docs/readme.md
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cspark-0.1.10-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version][version-img]][version-url]

  The Coherent Spark Python SDK is designed to elevate the developer experience and
  provide convenient access to Coherent Spark APIs.

  👋 **Just a heads-up:**

  This SDK is supported by the community. If you encounter any bumps while using it,
  please report them [here](https://github.com/Coherent-Partners/spark-python-sdk/issues)
  by creating a new issue.



  ```bash
  pip install cspark # or pip install 'cspark[cli]' for CLI support.
  ```

  > 🫣 This Python library requires [Python 3.7+](https://www.python.org/downloads/).



  To use the SDK, you need a Coherent Spark account that lets you access the following:

  - User authentication ([API key][api-key-docs], [bearer token][bearer-token-docs],
    or [OAuth2.0 client credentials][oauth2-docs] details)
  - Base URL (including the environment and tenant name)
  - Spark service URI (to locate a specific resource):
    - `folder` - the folder name (where the service is located)
    - `service` - the service name
    - `version` - the semantic version a.k.a revision number (e.g., 0.4.2)

  A `folder` contains one or more `service`s, which can have multiple `version`s.
  Technically speaking, when you're operating with a service, you're actually
  interacting with a specific version of that service (the latest version by default -
  unless specified otherwise).

  Hence, there are various ways to indicate a Spark service URI:

  - `{folder}/{service}[?{version}]` - _version_ is optional.
  - `service/{service_id}`
  - `version/{version_id}`

  > **IMPORTANT:** Avoid using URL-encoded characters in the service URI.

  Here's an example of how to execute a Spark service:

  ```py
  import cspark.sdk as Spark

  spark = Spark.Client(env='my-env', tenant='my-tenant', api_key='my-api-key')
  with spark.services as services:
      response = services.execute('my-folder/my-service', inputs={'value': 42})
      print(response.data)
  ```

  Explore the [examples] and [docs] folders to find out more about the SDK's capabilities.

  > **PRO TIP:**
  > A service URI locator can be combined with other parameters to locate a specific
  > service (or version of it) when it's not a string. For example, you may execute
  > a public service using a `UriParams` object by specifying the `folder`, `service`,
  > and `public` properties.

  ```py
  import cspark.sdk as Spark

  spark = Spark.Client(env='my-env', tenant='my-tenant', api_key='open')

  with spark.services as services:
      uri = Spark.UriParams(folder='my-folder', service='my-service', public=True)
      response = services.execute(uri, inputs={'value': 42})
      print(response.data)



  ```

  See the [Uri and UriParams][uri-url] classes for more details.



  As shown in the examples above, the `Spark.Client` is your entry point to the SDK.
  It is quite flexible and can be configured with the following options:



  `base_url` (default: `os.getenv['CSPARK_BASE_URL']`) indicates the base URL of
  Coherent Spark APIs. It should include the tenant and environment information.

  ```py
  spark = Spark.Client(base_url='https://excel.my-env.coherent.global/my-tenant')
  ```

  Alternatively, a combination of `env` and `tenant` options can be used to construct
  the base URL.

  ```py
  spark = Spark.Client(env='my-env', tenant='my-tenant')
  ```



  The SDK supports three types of authentication schemes:

  - `api_key` (default: `os.getenv['CSPARK_API_KEY']`) indicates the API key
    (also known as synthetic key), which is sensitive and should be kept secure.

  ```py
  spark = Spark.Client(api_key='my-api-key')
  ```

  > **PRO TIP:**
  > The Spark platform supports public APIs that can be accessed without any form
  > of authentication. In that case, you need to set `api_key` to `open` in order to
  > create a `Spark.Client`.

  - `token` (default: `os.getenv['CSPARK_BEARER_TOKEN']`) indicates the bearer token.
    It can be prefixed with 'Bearer' or not. A bearer token is usually valid for a
    limited time and should be refreshed periodically.

  ```py
  spark = Spark.Client(token='Bearer my-access-token') # with prefix

  spark = Spark.Client(token='my-access-token') # without prefix
  ```

  - `oauth` (default: `os.getenv['CSPARK_CLIENT_ID']` and `os.getenv['CSPARK_CLIENT_SECRET']` or
    `os.getenv['CSPARK_OAUTH_PATH']`) indicates the OAuth2.0 client credentials.
    You can either provide the client ID and secret directly or the file path to
    the JSON file containing the credentials.

  ```py
  spark = Spark.Client(oauth={'client_id': 'my-client-id', 'client_secret': 'my-client-secret'})

  spark = Spark.Client(oauth='path/to/oauth/credentials.json')
  ```



  - `timeout` (default: `60000` ms) indicates the maximum amount of time that the
    client should wait for a response from Spark servers before timing out a request.

  - `max_retries` (default: `2`) indicates the maximum number of times that the client
    will retry a request in case of a temporary failure, such as an unauthorized
    response or a status code greater than 400.

  - `retry_interval` (default: `1` second) indicates the delay between each retry.

  - `logger` (default: `True`) enables or disables the logger for the SDK.
    - If `bool`, determines whether or not the SDK should print logs.
    - If `dict`, the SDK will print logs in accordance with the specified keyword arguments.
    - If `LoggerOptions`, the SDK will print messages based on the specified options:
      - `context` (default: `CSPARK v{version}`): defines the context of the logs (e.g., `CSPARK v0.1.6`);
      - `disabled` (default: `False`) determines whether the logger should be disabled.
      - `colorful` (default: `True`) determines whether the logs should be colorful;
      - `timestamp` (default: `True`) determines whether the logs should include timestamps;
      - `datefmt` (default: `'%m/%d/%Y, %I:%M:%SOURCE%p'`)
      - `level` (default: `DEBUG`) defines the [logging level][logging-level] for the logs.

  ```py
  spark = Spark.Client(logger=False)

  spark = Spark.Client(logger={'colorful': False})
  ```



  `SparkError` is the base class for all custom errors thrown by the SDK. There are
  two types of it:

  - `SparkSdkError`: usually thrown when an argument (user entry) fails to comply
    with the expected format. Because it's a client-side error, it will include the invalid
    entry as the `cause` in most cases.
  - `SparkApiError`: when attempting to communicate with the API, the SDK will wrap
    any sort of failure (any error during the roundtrip) into `SparkApiError`, which
    includes the HTTP `status` code of the response and the `request_id`, a unique
    identifier of the request.

  Some of the derived `SparkApiError` are:

  | Type                      | Status | When                           |
  | ------------------------- | ------ | ------------------------------ |
  | `BadRequestError`         | 400    | invalid request                |
  | `UnauthorizedError`       | 401    | missing or invalid credentials |
  | `ForbiddenError`          | 403    | insufficient permissions       |
  | `NotFoundError`           | 404    | resource not found             |
  | `ConflictError`           | 409    | resource already exists        |
  | `RateLimitError`          | 429    | too many requests              |
  | `InternalServerError`     | 500    | server-side error              |
  | `ServiceUnavailableError` | 503    | server is down                 |
  | `UnknownApiError`         | `None` | unknown error                  |



  The SDK aims to provide full parity with the Spark APIs over time. Below is a list
  of the currently supported APIs.

  [Authentication API](./docs/authentication.md) - manages access tokens using
  OAuth2.0 Client Credentials flow:

  - `Authorization.oauth.retrieve_token(config)` generates new access tokens.

  [Services API](./docs/services.md) - manages Spark services:

  - `Spark.services.create(data)` creates a new Spark service.
  - `Spark.services.execute(uri, inputs)` executes a Spark service.
  - `Spark.services.transform(uri, inputs)` executes a Spark service using `Transforms`.
  - `Spark.services.get_versions(uri)` lists all the versions of a service.
  - `Spark.services.get_schema(uri)` gets the schema of a service.
  - `Spark.services.get_metadata(uri)` gets the metadata of a service.
  - `Spark.services.download(uri)` downloads the excel file of a service.
  - `Spark.services.recompile(uri)` recompiles a service using specific compiler versions.
  - `Spark.services.validate(uri, data)` validates input data using static or dynamic validations.
  - `Spark.services.delete(uri)` deletes an existing service, including all its versions.

  [Batches API](./docs/batches.md) - manages asynchronous batch processing:

  - `Spark.batches.describe()` describes the batch pipelines across a tenant.
  - `Spark.batches.create(params, [options])` creates a new batch pipeline.
  - `Spark.batches.of(id)` defines a client-side batch pipeline by ID.
  - `Spark.batches.of(id).get_info()` gets the details of a batch pipeline.
  - `Spark.batches.of(id).get_status()` gets the status of a batch pipeline.
  - `Spark.batches.of(id).push(data, [options])` adds input data to a batch pipeline.
  - `Spark.batches.of(id).pull([options])` retrieves the output data from a batch pipeline.
  - `Spark.batches.of(id).dispose()` closes a batch pipeline.
  - `Spark.batches.of(id).cancel()` cancels a batch pipeline.

  [Log History API](./docs/history.md) - manages service execution logs:

  - `Spark.logs.rehydrate(uri, call_id)` rehydrates the executed model into the original Excel file.
  - `Spark.logs.download(data)` downloads service execution logs as `csv` or `json` file.

  [ImpEx API](./docs/impex.md) - imports and exports Spark services:

  - `Spark.impex.export(data)` exports Spark entities (versions, services, or folders).
  - `Spark.impex.import_(data)` imports previously exported Spark entities into the platform.

  [Other APIs](./docs/misc.md) - for other functionality:

  - `Spark.wasm.download(uri)` downloads a service's WebAssembly module.
  - `Spark.files.download(url)` downloads temporary files issued by the Spark platform.



  Feeling motivated enough to contribute? Great! Your help is always appreciated.

  Please read [CONTRIBUTING.md][contributing-url] for details on the code of
  conduct, and the process for submitting pull requests.



  [Apache-2.0][license-url]

  <!-- References -->
  [version-img]: https://badge.fury.io/py/cspark.svg
  [version-url]: https://pypi.python.org/pypi/cspark
  [api-key-docs]: https://docs.coherent.global/spark-apis/authorization-api-keys
  [bearer-token-docs]: https://docs.coherent.global/spark-apis/authorization-bearer-token
  [oauth2-docs]: https://docs.coherent.global/spark-apis/authorization-client-credentials
  [contributing-url]: https://github.com/Coherent-Partners/spark-python-sdk/blob/main/CONTRIBUTING.md
  [license-url]: https://github.com/Coherent-Partners/spark-python-sdk/blob/main/LICENSE
  [examples]: https://github.com/Coherent-Partners/spark-python-sdk/tree/main/examples
  [docs]: https://github.com/Coherent-Partners/spark-python-sdk/tree/main/docs
  [uri-url]: https://github.com/Coherent-Partners/spark-python-sdk/blob/main/src/cspark/sdk/resources/_base.py
  [logging-level]: https://docs.python.org/3/library/logging.html#logging-levels


pkgId: f20793ec1ee211c897b2a1ebcfef0d2a5dad4af9a294be59eb9688cb230a8445
name: python-cspark
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: A Python SDK for interacting with Coherent Spark APIs
url: https://github.com/Coherent-Partners/spark-python-sdk/blob/main/docs/readme.md
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cspark-0.1.9-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version][version-img]][version-url]

  The Coherent Spark Python SDK (currently in **Beta**) is designed to elevate the developer
  experience and provide convenient access to Coherent Spark APIs.

  👋 **Just a heads-up:**

  This SDK is supported by the community. If you encounter any bumps while using it,
  please report them [here](https://github.com/Coherent-Partners/spark-python-sdk/issues)
  by creating a new issue.



  ```bash
  pip install cspark # or pip install 'cspark[cli]' for CLI support.
  ```

  > 🫣 This Python library requires [Python 3.7+](https://www.python.org/downloads/).



  To use the SDK, you need a Coherent Spark account that lets you access the following:

  - User authentication ([API key][api-key-docs], [bearer token][bearer-token-docs],
    or [OAuth2.0 client credentials][oauth2-docs] details)
  - Base URL (including the environment and tenant name)
  - Spark service URI (to locate a specific resource):
    - `folder` - the folder name (where the service is located)
    - `service` - the service name
    - `version` - the semantic version a.k.a revision number (e.g., 0.4.2)

  A `folder` contains one or more `service`s, which can have multiple `version`s.
  Technically speaking, when you're operating with a service, you're actually
  interacting with a specific version of that service (the latest version by default -
  unless specified otherwise).

  Hence, there are various ways to indicate a Spark service URI:

  - `{folder}/{service}[?{version}]` - _version_ is optional.
  - `service/{service_id}`
  - `version/{version_id}`

  > **IMPORTANT:** Avoid using URL-encoded characters in the service URI.

  Here's an example of how to execute a Spark service:

  ```py
  import cspark.sdk as Spark

  spark = Spark.Client(env='my-env', tenant='my-tenant', api_key='my-api-key')
  with spark.services as services:
      response = services.execute('my-folder/my-service', inputs={'value': 42})
      print(response.data)
  ```

  Explore the [examples] and [documentation] folders to find out more about the SDK's capabilities.

  > **PRO TIP:**
  > A service URI locator can be combined with other parameters to locate a specific
  > service (or version of it) when it's not a string. For example, you may execute
  > a public service using a `UriParams` object by specifying the `folder`, `service`,
  > and `public` properties.

  ```py
  import cspark.sdk as Spark

  spark = Spark.Client(env='my-env', tenant='my-tenant', api_key='open')

  with spark.services as services:
      uri = Spark.UriParams(folder='my-folder', service='my-service', public=True)
      response = services.execute(uri, inputs={'value': 42})
      print(response.data)



  ```

  See the [Uri and UriParams](./src/cspark/sdk/resources/_base.py) classes for more details.



  As shown in the examples above, the `Spark.Client` is your entry point to the SDK.
  It is quite flexible and can be configured with the following options:



  `base_url` (default: `os.getenv['CSPARK_BASE_URL']`) indicates the base URL of
  Coherent Spark APIs. It should include the tenant and environment information.

  ```py
  spark = Spark.Client(base_url='https://excel.my-env.coherent.global/my-tenant')
  ```

  Alternatively, a combination of `env` and `tenant` options can be used to construct
  the base URL.

  ```py
  spark = Spark.Client(env='my-env', tenant='my-tenant')
  ```



  The SDK supports three types of authentication schemes:

  - `api_key` (default: `os.getenv['CSPARK_API_KEY']`) indicates the API key
    (also known as synthetic key), which is sensitive and should be kept secure.

  ```py
  spark = Spark.Client(api_key='my-api-key')
  ```

  > **PRO TIP:**
  > The Spark platform supports public APIs that can be accessed without any form
  > of authentication. In that case, you need to set `api_key` to `open` in order to
  > create a `Spark.Client`.

  - `token` (default: `os.getenv['CSPARK_BEARER_TOKEN']`) indicates the bearer token.
    It can be prefixed with 'Bearer' or not. A bearer token is usually valid for a
    limited time and should be refreshed periodically.

  ```py
  spark = Spark.Client(token='Bearer my-access-token') # with prefix

  spark = Spark.Client(token='my-access-token') # without prefix
  ```

  - `oauth` (default: `os.getenv['CSPARK_CLIENT_ID']` and `os.getenv['CSPARK_CLIENT_SECRET']` or
    `os.getenv['CSPARK_OAUTH_PATH']`) indicates the OAuth2.0 client credentials.
    You can either provide the client ID and secret directly or the file path to
    the JSON file containing the credentials.

  ```py
  spark = Spark.Client(oauth={'client_id': 'my-client-id', 'client_secret': 'my-client-secret'})

  spark = Spark.Client(oauth='path/to/oauth/credentials.json')
  ```



  - `timeout` (default: `60000` ms) indicates the maximum amount of time that the
    client should wait for a response from Spark servers before timing out a request.

  - `max_retries` (default: `2`) indicates the maximum number of times that the client
    will retry a request in case of a temporary failure, such as an unauthorized
    response or a status code greater than 400.

  - `retry_interval` (default: `1` second) indicates the delay between each retry.

  - `logger` (default: `True`) enables or disables the logger for the SDK.
    - If `bool`, determines whether or not the SDK should print logs.
    - If `dict`, the SDK will print logs in accordance with the specified keyword arguments.
    - If `LoggerOptions`, the SDK will print messages based on the specified options:
      - `context` (default: `CSPARK v{version}`): defines the context of the logs (e.g., `CSPARK v0.1.6`);
      - `disabled` (default: `False`) determines whether the logger should be disabled.
      - `colorful` (default: `True`) determines whether the logs should be colorful;
      - `timestamp` (default: `True`) determines whether the logs should include timestamps;
      - `datefmt` (default: `'%m/%d/%Y, %I:%M:%SOURCE%p'`)
      - `level` (default: `DEBUG`) defines the [logging level][logging-level] for the logs.

  ```py
  spark = Spark.Client(logger=False)

  spark = Spark.Client(logger={'colorful': False})
  ```



  `SparkError` is the base class for all custom errors thrown by the SDK. There are
  two types of it:

  - `SparkSdkError`: usually thrown when an argument (user entry) fails to comply
    with the expected format. Because it's a client-side error, it will include the invalid
    entry as the `cause` in most cases.
  - `SparkApiError`: when attempting to communicate with the API, the SDK will wrap
    any sort of failure (any error during the roundtrip) into `SparkApiError`, which
    includes the HTTP `status` code of the response and the `request_id`, a unique
    identifier of the request.

  Some of the derived `SparkApiError` are:

  | Type                      | Status | When                           |
  | ------------------------- | ------ | ------------------------------ |
  | `BadRequestError`         | 400    | invalid request                |
  | `UnauthorizedError`       | 401    | missing or invalid credentials |
  | `ForbiddenError`          | 403    | insufficient permissions       |
  | `NotFoundError`           | 404    | resource not found             |
  | `ConflictError`           | 409    | resource already exists        |
  | `RateLimitError`          | 429    | too many requests              |
  | `InternalServerError`     | 500    | server-side error              |
  | `ServiceUnavailableError` | 503    | server is down                 |
  | `UnknownApiError`         | `None` | unknown error                  |



  The SDK aims to provide full parity with the Spark APIs over time. Below is a list
  of the currently supported APIs.

  [Authentication API](./docs/authentication.md) - manages access tokens using
  OAuth2.0 Client Credentials flow:

  - `Authorization.oauth.retrieve_token(config)` generates new access tokens.

  [Services API](./docs/services.md) - manages Spark services:

  - `Spark.services.create(data)` creates a new Spark service.
  - `Spark.services.execute(uri, inputs)` executes a Spark service.
  - `Spark.services.transform(uri, inputs)` executes a Spark service using `Transforms`.
  - `Spark.services.get_versions(uri)` lists all the versions of a service.
  - `Spark.services.get_schema(uri)` gets the schema of a service.
  - `Spark.services.get_metadata(uri)` gets the metadata of a service.
  - `Spark.services.download(uri)` downloads the excel file of a service.
  - `Spark.services.recompile(uri)` recompiles a service using specific compiler versions.
  - `Spark.services.validate(uri, data)` validates input data using static or dynamic validations.
  - `Spark.services.delete(uri)` deletes an existing service, including all its versions.

  [Batches API](./docs/batches.md) - manages asynchronous batch processing:

  - `Spark.batches.describe()` describes the batch pipelines across a tenant.
  - `Spark.batches.create(params, [options])` creates a new batch pipeline.
  - `Spark.batches.of(id)` defines a client-side batch pipeline by ID.
  - `Spark.batches.of(id).get_info()` gets the details of a batch pipeline.
  - `Spark.batches.of(id).get_status()` gets the status of a batch pipeline.
  - `Spark.batches.of(id).push(data, [options])` adds input data to a batch pipeline.
  - `Spark.batches.of(id).pull([options])` retrieves the output data from a batch pipeline.
  - `Spark.batches.of(id).dispose()` closes a batch pipeline.
  - `Spark.batches.of(id).cancel()` cancels a batch pipeline.

  [Log History API](./docs/history.md) - manages service execution logs:

  - `Spark.logs.rehydrate(uri, call_id)` rehydrates the executed model into the original Excel file.
  - `Spark.logs.download(data)` downloads service execution logs as `csv` or `json` file.

  [ImpEx API](./docs/impex.md) - imports and exports Spark services:

  - `Spark.impex.export(data)` exports Spark entities (versions, services, or folders).
  - `Spark.impex.import_(data)` imports previously exported Spark entities into the platform.

  [Other APIs](./docs/misc.md) - for other functionalities:

  - `Spark.wasm.download(uri)` downloads a service's WebAssembly module.
  - `Spark.files.download(url)` downloads temporary files issued by the Spark platform.



  Feeling motivated enough to contribute? Great! Your help is always appreciated.

  Please read [CONTRIBUTING.md][contributing-url] for details on the code of
  conduct, and the process for submitting pull requests.



  [Apache-2.0][license-url]

  <!-- References -->
  [version-img]: https://badge.fury.io/py/cspark.svg
  [version-url]: https://pypi.python.org/pypi/cspark
  [api-key-docs]: https://docs.coherent.global/spark-apis/authorization-api-keys
  [bearer-token-docs]: https://docs.coherent.global/spark-apis/authorization-bearer-token
  [oauth2-docs]: https://docs.coherent.global/spark-apis/authorization-client-credentials
  [contributing-url]: https://github.com/Coherent-Partners/spark-python-sdk/blob/main/CONTRIBUTING.md
  [license-url]: https://github.com/Coherent-Partners/spark-python-sdk/blob/main/LICENSE
  [examples]: https://github.com/Coherent-Partners/spark-python-sdk/tree/main/examples
  [documentation]: https://github.com/Coherent-Partners/spark-python-sdk/tree/main/docs
  [logging-level]: https://docs.python.org/3/library/logging.html#logging-levels


